mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-11-10 18:15:19 +00:00
eb856b5a1f
* delete incentive reward index on repay/withdraw * call hook on borrow in all cases * additional types functionality * extend tests to cover fix * update naming convention in tests * update test comment * feat: add set difference unit tests * clarify test names Co-authored-by: karzak <kjydavis3@gmail.com>
2927 lines
127 KiB
Go
2927 lines
127 KiB
Go
package keeper_test
|
|
|
|
import (
|
|
"time"
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
"github.com/cosmos/cosmos-sdk/x/params"
|
|
"github.com/cosmos/cosmos-sdk/x/staking"
|
|
abci "github.com/tendermint/tendermint/abci/types"
|
|
"github.com/tendermint/tendermint/crypto/ed25519"
|
|
|
|
cdptypes "github.com/kava-labs/kava/x/cdp/types"
|
|
"github.com/kava-labs/kava/x/committee"
|
|
"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.Coins
|
|
initialTime time.Time
|
|
timeElapsed int
|
|
expectedRewardIndexes types.RewardIndexes
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
}
|
|
testCases := []test{
|
|
{
|
|
"single reward denom: 7 seconds",
|
|
args{
|
|
borrow: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 7,
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.000000856478000001"))},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: 1 day",
|
|
args{
|
|
borrow: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 86400,
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.010571385600010177"))},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: 0 seconds",
|
|
args{
|
|
borrow: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 0,
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.0"))},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: 7 seconds",
|
|
args{
|
|
borrow: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 7,
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.000000856478000001")),
|
|
types.NewRewardIndex("ukava", d("0.000000856478000001")),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: 1 day",
|
|
args{
|
|
borrow: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 86400,
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.010571385600010177")),
|
|
types.NewRewardIndex("ukava", d("0.010571385600010177")),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: 0 seconds",
|
|
args{
|
|
borrow: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 0,
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
types.NewRewardIndex("ukava", d("0.0")),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms with different rewards per second: 1 day",
|
|
args{
|
|
borrow: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 555555)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 86400,
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.010571385600010177")),
|
|
types.NewRewardIndex("ukava", d("0.047999952000046210")),
|
|
},
|
|
},
|
|
},
|
|
}
|
|
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[0])},
|
|
types.MultiRewardPeriods{types.NewMultiRewardPeriod(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), 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[0])},
|
|
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)
|
|
var rewardIndexes types.RewardIndexes
|
|
for _, rewardCoin := range tc.args.rewardsPerSecond {
|
|
rewardIndex := types.NewRewardIndex(rewardCoin.Denom, sdk.ZeroDec())
|
|
rewardIndexes = append(rewardIndexes, rewardIndex)
|
|
}
|
|
suite.keeper.SetHardBorrowRewardIndexes(suite.ctx, tc.args.borrow.Denom, rewardIndexes)
|
|
|
|
// 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)
|
|
|
|
// Accumulate hard borrow rewards for the deposit denom
|
|
multiRewardPeriod, found := suite.keeper.GetHardBorrowRewardPeriods(runCtx, tc.args.borrow.Denom)
|
|
suite.Require().True(found)
|
|
err = suite.keeper.AccumulateHardBorrowRewards(runCtx, multiRewardPeriod)
|
|
suite.Require().NoError(err)
|
|
|
|
// Check that each expected reward index matches the current stored reward index for the denom
|
|
globalRewardIndexes, found := suite.keeper.GetHardBorrowRewardIndexes(runCtx, tc.args.borrow.Denom)
|
|
suite.Require().True(found)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
globalRewardIndex, found := globalRewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, globalRewardIndex)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestSynchronizeHardBorrowReward() {
|
|
type args struct {
|
|
incentiveBorrowRewardDenom string
|
|
borrow sdk.Coin
|
|
rewardsPerSecond sdk.Coins
|
|
initialTime time.Time
|
|
blockTimes []int
|
|
expectedRewardIndexes types.RewardIndexes
|
|
expectedRewards sdk.Coins
|
|
updateRewardsViaCommmittee bool
|
|
updatedBaseDenom string
|
|
updatedRewardsPerSecond sdk.Coins
|
|
updatedExpectedRewardIndexes types.RewardIndexes
|
|
updatedExpectedRewards sdk.Coins
|
|
updatedTimeDuration int
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
}
|
|
|
|
testCases := []test{
|
|
{
|
|
"single reward denom: 10 blocks",
|
|
args{
|
|
incentiveBorrowRewardDenom: "bnb",
|
|
borrow: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.001223540000173228"))},
|
|
expectedRewards: cs(c("hard", 12235400)),
|
|
updateRewardsViaCommmittee: false,
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: 10 blocks - long block time",
|
|
args{
|
|
incentiveBorrowRewardDenom: "bnb",
|
|
borrow: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("10.571385603126235340"))},
|
|
expectedRewards: cs(c("hard", 105713856031)),
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: user reward index updated when reward is zero",
|
|
args{
|
|
incentiveBorrowRewardDenom: "ukava",
|
|
borrow: c("ukava", 1), // borrow a tiny amount so that rewards round to zero
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.122354003908172328"))},
|
|
expectedRewards: cs(),
|
|
updateRewardsViaCommmittee: false,
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: 10 blocks",
|
|
args{
|
|
incentiveBorrowRewardDenom: "bnb",
|
|
borrow: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 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},
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.001223540000173228")),
|
|
types.NewRewardIndex("ukava", d("0.001223540000173228")),
|
|
},
|
|
expectedRewards: cs(c("hard", 12235400), c("ukava", 12235400)),
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: 10 blocks - long block time",
|
|
args{
|
|
incentiveBorrowRewardDenom: "bnb",
|
|
borrow: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 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},
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("10.571385603126235340")),
|
|
types.NewRewardIndex("ukava", d("10.571385603126235340")),
|
|
},
|
|
expectedRewards: cs(c("hard", 105713856031), c("ukava", 105713856031)),
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms with different rewards per second: 10 blocks",
|
|
args{
|
|
incentiveBorrowRewardDenom: "bnb",
|
|
borrow: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 555555)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.001223540000173228")),
|
|
types.NewRewardIndex("ukava", d("0.005555550000786558")),
|
|
},
|
|
expectedRewards: cs(c("hard", 12235400), c("ukava", 55555500)),
|
|
},
|
|
},
|
|
{
|
|
"denom is in incentive's hard borrow reward params but it has no rewards; add reward",
|
|
args{
|
|
incentiveBorrowRewardDenom: "bnb",
|
|
borrow: c("bnb", 10000000000),
|
|
rewardsPerSecond: sdk.Coins{},
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{100},
|
|
expectedRewardIndexes: types.RewardIndexes{},
|
|
expectedRewards: sdk.Coins{},
|
|
updateRewardsViaCommmittee: true,
|
|
updatedBaseDenom: "bnb",
|
|
updatedRewardsPerSecond: cs(c("hard", 100000)),
|
|
updatedExpectedRewards: cs(c("hard", 8640000000)),
|
|
updatedExpectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.864000000049803065")),
|
|
},
|
|
updatedTimeDuration: 86400,
|
|
},
|
|
},
|
|
{
|
|
"denom is in incentive's hard borrow reward params and has rewards; add new reward type",
|
|
args{
|
|
incentiveBorrowRewardDenom: "bnb",
|
|
borrow: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{86400},
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("1.057138560060101160")),
|
|
},
|
|
expectedRewards: cs(c("hard", 10571385601)),
|
|
updateRewardsViaCommmittee: true,
|
|
updatedBaseDenom: "bnb",
|
|
updatedRewardsPerSecond: cs(c("hard", 122354), c("ukava", 100000)),
|
|
updatedExpectedRewards: cs(c("hard", 21142771202), c("ukava", 8640000000)),
|
|
updatedExpectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("2.114277120120202320")),
|
|
types.NewRewardIndex("ukava", d("0.864000000049120715")),
|
|
},
|
|
updatedTimeDuration: 86400,
|
|
},
|
|
},
|
|
{
|
|
"denom is in hard's money market params but not in incentive's hard supply reward params; add reward",
|
|
args{
|
|
incentiveBorrowRewardDenom: "bnb",
|
|
borrow: c("zzz", 10000000000),
|
|
rewardsPerSecond: sdk.Coins{},
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{100},
|
|
expectedRewardIndexes: types.RewardIndexes{},
|
|
expectedRewards: sdk.Coins{},
|
|
updateRewardsViaCommmittee: true,
|
|
updatedBaseDenom: "zzz",
|
|
updatedRewardsPerSecond: cs(c("hard", 100000)),
|
|
updatedExpectedRewards: cs(c("hard", 8640000000)),
|
|
updatedExpectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.864000000049803065")),
|
|
},
|
|
updatedTimeDuration: 86400,
|
|
},
|
|
},
|
|
{
|
|
"denom incentive's hard borrow reward params but it has no rewards; add multiple reward types",
|
|
args{
|
|
incentiveBorrowRewardDenom: "bnb",
|
|
borrow: c("bnb", 10000000000),
|
|
rewardsPerSecond: sdk.Coins{},
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{100},
|
|
expectedRewardIndexes: types.RewardIndexes{},
|
|
expectedRewards: sdk.Coins{},
|
|
updateRewardsViaCommmittee: true,
|
|
updatedBaseDenom: "bnb",
|
|
updatedRewardsPerSecond: cs(c("hard", 100000), c("ukava", 100500), c("swap", 500)),
|
|
updatedExpectedRewards: cs(c("hard", 8640000000), c("ukava", 8683200001), c("swap", 43200000)),
|
|
updatedExpectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.864000000049803065")),
|
|
types.NewRewardIndex("ukava", d("0.868320000050052081")),
|
|
types.NewRewardIndex("swap", d("0.004320000000249015")),
|
|
},
|
|
updatedTimeDuration: 86400,
|
|
},
|
|
},
|
|
{
|
|
"denom is in hard's money market params but not in incentive's hard supply reward params; add multiple reward types",
|
|
args{
|
|
incentiveBorrowRewardDenom: "bnb",
|
|
borrow: c("zzz", 10000000000),
|
|
rewardsPerSecond: sdk.Coins{},
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{100},
|
|
expectedRewardIndexes: types.RewardIndexes{},
|
|
expectedRewards: sdk.Coins{},
|
|
updateRewardsViaCommmittee: true,
|
|
updatedBaseDenom: "zzz",
|
|
updatedRewardsPerSecond: cs(c("hard", 100000), c("ukava", 100500), c("swap", 500)),
|
|
updatedExpectedRewards: cs(c("hard", 8640000000), c("ukava", 8683200001), c("swap", 43200000)),
|
|
updatedExpectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.864000000049803065")),
|
|
types.NewRewardIndex("ukava", d("0.868320000050052081")),
|
|
types.NewRewardIndex("swap", d("0.004320000000249015")),
|
|
},
|
|
updatedTimeDuration: 86400,
|
|
},
|
|
},
|
|
}
|
|
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
|
|
incentiveParams := types.NewParams(
|
|
types.RewardPeriods{types.NewRewardPeriod(true, tc.args.incentiveBorrowRewardDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), c("hard", 1))},
|
|
types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.incentiveBorrowRewardDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), sdk.Coins{})}, // Don't set any supply rewards for easier accounting
|
|
types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.incentiveBorrowRewardDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)},
|
|
types.RewardPeriods{types.NewRewardPeriod(true, tc.args.incentiveBorrowRewardDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), c("hard", 1))},
|
|
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, incentiveParams)
|
|
suite.keeper.SetPreviousHardBorrowRewardAccrualTime(suite.ctx, tc.args.incentiveBorrowRewardDenom, tc.args.initialTime)
|
|
var rewardIndexes types.RewardIndexes
|
|
for _, rewardCoin := range tc.args.rewardsPerSecond {
|
|
rewardIndex := types.NewRewardIndex(rewardCoin.Denom, sdk.ZeroDec())
|
|
rewardIndexes = append(rewardIndexes, rewardIndex)
|
|
}
|
|
if len(rewardIndexes) > 0 {
|
|
suite.keeper.SetHardBorrowRewardIndexes(suite.ctx, tc.args.incentiveBorrowRewardDenom, rewardIndexes)
|
|
}
|
|
|
|
// 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)
|
|
// Set the minimum borrow to 0 to allow testing small borrows
|
|
hardParams := suite.hardKeeper.GetParams(suite.ctx)
|
|
hardParams.MinimumBorrowUSDValue = sdk.ZeroDec()
|
|
suite.hardKeeper.SetParams(suite.ctx, hardParams)
|
|
|
|
// Borrow a fixed amount from another user to dilute primary user's rewards per second.
|
|
suite.Require().NoError(
|
|
suite.hardKeeper.Deposit(suite.ctx, suite.addrs[2], cs(c("ukava", 200_000_000))),
|
|
)
|
|
suite.Require().NoError(
|
|
suite.hardKeeper.Borrow(suite.ctx, suite.addrs[2], cs(c("ukava", 100_000_000))),
|
|
)
|
|
|
|
// 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, userAddr)
|
|
suite.Require().True(found)
|
|
multiRewardIndex, _ := claim.BorrowRewardIndexes.GetRewardIndex(tc.args.borrow.Denom)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
currRewardIndex, found := multiRewardIndex.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(sdk.ZeroDec(), currRewardIndex.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)
|
|
|
|
// Accumulate hard borrow-side rewards
|
|
multiRewardPeriod, found := suite.keeper.GetHardBorrowRewardPeriods(blockCtx, tc.args.borrow.Denom)
|
|
if found {
|
|
err := suite.keeper.AccumulateHardBorrowRewards(blockCtx, multiRewardPeriod)
|
|
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, userAddr)
|
|
suite.Require().True(found)
|
|
suite.Require().NotPanics(func() {
|
|
suite.keeper.SynchronizeHardBorrowReward(suite.ctx, borrow)
|
|
})
|
|
|
|
// Check that the global reward index's reward factor and user's claim have been updated as expected
|
|
claim, found = suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, userAddr)
|
|
suite.Require().True(found)
|
|
globalRewardIndexes, foundGlobalRewardIndexes := suite.keeper.GetHardBorrowRewardIndexes(suite.ctx, tc.args.borrow.Denom)
|
|
if len(tc.args.rewardsPerSecond) > 0 {
|
|
suite.Require().True(foundGlobalRewardIndexes)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
// Check that global reward index has been updated as expected
|
|
globalRewardIndex, found := globalRewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, globalRewardIndex)
|
|
|
|
// Check that the user's claim's reward index matches the corresponding global reward index
|
|
multiRewardIndex, found := claim.BorrowRewardIndexes.GetRewardIndex(tc.args.borrow.Denom)
|
|
suite.Require().True(found)
|
|
rewardIndex, found := multiRewardIndex.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, rewardIndex)
|
|
|
|
// Check that the user's claim holds the expected amount of reward coins
|
|
suite.Require().Equal(
|
|
tc.args.expectedRewards.AmountOf(expectedRewardIndex.CollateralType),
|
|
claim.Reward.AmountOf(expectedRewardIndex.CollateralType),
|
|
)
|
|
}
|
|
}
|
|
|
|
// Only test cases with reward param updates continue past this point
|
|
if !tc.args.updateRewardsViaCommmittee {
|
|
return
|
|
}
|
|
|
|
// If are no initial rewards per second, add new rewards through a committee param change
|
|
// 1. Construct incentive's new HardBorrowRewardPeriods param
|
|
currIncentiveHardBorrowRewardPeriods := suite.keeper.GetParams(suite.ctx).HardBorrowRewardPeriods
|
|
multiRewardPeriod, found := currIncentiveHardBorrowRewardPeriods.GetMultiRewardPeriod(tc.args.borrow.Denom)
|
|
if found {
|
|
// Borrow denom's reward period exists, but it doesn't have any rewards per second
|
|
index, found := currIncentiveHardBorrowRewardPeriods.GetMultiRewardPeriodIndex(tc.args.borrow.Denom)
|
|
suite.Require().True(found)
|
|
multiRewardPeriod.RewardsPerSecond = tc.args.updatedRewardsPerSecond
|
|
currIncentiveHardBorrowRewardPeriods[index] = multiRewardPeriod
|
|
} else {
|
|
// Borrow denom's reward period does not exist
|
|
_, found := currIncentiveHardBorrowRewardPeriods.GetMultiRewardPeriodIndex(tc.args.borrow.Denom)
|
|
suite.Require().False(found)
|
|
newMultiRewardPeriod := types.NewMultiRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.updatedRewardsPerSecond)
|
|
currIncentiveHardBorrowRewardPeriods = append(currIncentiveHardBorrowRewardPeriods, newMultiRewardPeriod)
|
|
}
|
|
|
|
// 2. Construct the parameter change proposal to update HardBorrowRewardPeriods param
|
|
pubProposal := params.NewParameterChangeProposal(
|
|
"Update hard borrow rewards", "Adds a new reward coin to the incentive module's hard borrow rewards.",
|
|
[]params.ParamChange{
|
|
{
|
|
Subspace: types.ModuleName, // target incentive module
|
|
Key: string(types.KeyHardBorrowRewardPeriods), // target hard borrow rewards key
|
|
Value: string(suite.app.Codec().MustMarshalJSON(currIncentiveHardBorrowRewardPeriods)),
|
|
},
|
|
},
|
|
)
|
|
|
|
// 3. Ensure proposal is properly formed
|
|
err = suite.committeeKeeper.ValidatePubProposal(suite.ctx, pubProposal)
|
|
suite.Require().NoError(err)
|
|
|
|
// 4. Committee creates proposal
|
|
committeeMemberOne := suite.addrs[0]
|
|
committeeMemberTwo := suite.addrs[1]
|
|
proposalID, err := suite.committeeKeeper.SubmitProposal(suite.ctx, committeeMemberOne, 1, pubProposal)
|
|
suite.Require().NoError(err)
|
|
|
|
// 5. Committee votes and passes proposal
|
|
err = suite.committeeKeeper.AddVote(suite.ctx, proposalID, committeeMemberOne)
|
|
err = suite.committeeKeeper.AddVote(suite.ctx, proposalID, committeeMemberTwo)
|
|
|
|
// 6. Check proposal passed
|
|
proposalPasses, err := suite.committeeKeeper.GetProposalResult(suite.ctx, proposalID)
|
|
suite.Require().NoError(err)
|
|
suite.Require().True(proposalPasses)
|
|
|
|
// 7. Run committee module's begin blocker to enact proposal
|
|
suite.NotPanics(func() {
|
|
committee.BeginBlocker(suite.ctx, abci.RequestBeginBlock{}, suite.committeeKeeper)
|
|
})
|
|
|
|
// We need to accumulate hard supply-side rewards again
|
|
multiRewardPeriod, found = suite.keeper.GetHardBorrowRewardPeriods(suite.ctx, tc.args.borrow.Denom)
|
|
suite.Require().True(found)
|
|
|
|
// But new borrow denoms don't have their PreviousHardBorrowRewardAccrualTime set yet,
|
|
// so we need to call the accumulation method once to set the initial reward accrual time
|
|
if tc.args.borrow.Denom != tc.args.incentiveBorrowRewardDenom {
|
|
err = suite.keeper.AccumulateHardBorrowRewards(suite.ctx, multiRewardPeriod)
|
|
suite.Require().NoError(err)
|
|
}
|
|
|
|
// Now we can jump forward in time and accumulate rewards
|
|
updatedBlockTime = previousBlockTime.Add(time.Duration(int(time.Second) * tc.args.updatedTimeDuration))
|
|
suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime)
|
|
err = suite.keeper.AccumulateHardBorrowRewards(suite.ctx, multiRewardPeriod)
|
|
suite.Require().NoError(err)
|
|
|
|
// After we've accumulated, run synchronize
|
|
borrow, found = hardKeeper.GetBorrow(suite.ctx, userAddr)
|
|
suite.Require().True(found)
|
|
suite.Require().NotPanics(func() {
|
|
suite.keeper.SynchronizeHardBorrowReward(suite.ctx, borrow)
|
|
})
|
|
|
|
// Check that the global reward index's reward factor and user's claim have been updated as expected
|
|
globalRewardIndexes, found = suite.keeper.GetHardBorrowRewardIndexes(suite.ctx, tc.args.borrow.Denom)
|
|
suite.Require().True(found)
|
|
claim, found = suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, userAddr)
|
|
suite.Require().True(found)
|
|
|
|
for _, expectedRewardIndex := range tc.args.updatedExpectedRewardIndexes {
|
|
// Check that global reward index has been updated as expected
|
|
globalRewardIndex, found := globalRewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, globalRewardIndex)
|
|
// Check that the user's claim's reward index matches the corresponding global reward index
|
|
multiRewardIndex, found := claim.BorrowRewardIndexes.GetRewardIndex(tc.args.borrow.Denom)
|
|
suite.Require().True(found)
|
|
rewardIndex, found := multiRewardIndex.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, rewardIndex)
|
|
|
|
// Check that the user's claim holds the expected amount of reward coins
|
|
suite.Require().Equal(
|
|
tc.args.updatedExpectedRewards.AmountOf(expectedRewardIndex.CollateralType),
|
|
claim.Reward.AmountOf(expectedRewardIndex.CollateralType),
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
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) TestInitializeHardSupplyRewards() {
|
|
|
|
type args struct {
|
|
moneyMarketRewardDenoms map[string][]string
|
|
deposit sdk.Coins
|
|
initialTime time.Time
|
|
expectedClaimSupplyRewardIndexes types.MultiRewardIndexes
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
}
|
|
|
|
standardMoneyMarketRewardDenoms := map[string][]string{
|
|
"bnb": {"hard"},
|
|
"btcb": {"hard", "ukava"},
|
|
"xrp": {},
|
|
}
|
|
|
|
testCases := []test{
|
|
{
|
|
"single deposit denom, single reward denom",
|
|
args{
|
|
moneyMarketRewardDenoms: standardMoneyMarketRewardDenoms,
|
|
deposit: cs(c("bnb", 1000000000000)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedClaimSupplyRewardIndexes: types.MultiRewardIndexes{
|
|
types.NewMultiRewardIndex(
|
|
"bnb",
|
|
types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
},
|
|
),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"single deposit denom, multiple reward denoms",
|
|
args{
|
|
moneyMarketRewardDenoms: standardMoneyMarketRewardDenoms,
|
|
deposit: cs(c("btcb", 1000000000000)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedClaimSupplyRewardIndexes: types.MultiRewardIndexes{
|
|
types.NewMultiRewardIndex(
|
|
"btcb",
|
|
types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
types.NewRewardIndex("ukava", d("0.0")),
|
|
},
|
|
),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"single deposit denom, no reward denoms",
|
|
args{
|
|
moneyMarketRewardDenoms: standardMoneyMarketRewardDenoms,
|
|
deposit: cs(c("xrp", 1000000000000)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedClaimSupplyRewardIndexes: types.MultiRewardIndexes{
|
|
types.NewMultiRewardIndex(
|
|
"xrp",
|
|
nil,
|
|
),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"multiple deposit denoms, multiple overlapping reward denoms",
|
|
args{
|
|
moneyMarketRewardDenoms: standardMoneyMarketRewardDenoms,
|
|
deposit: cs(c("bnb", 1000000000000), c("btcb", 1000000000000)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedClaimSupplyRewardIndexes: types.MultiRewardIndexes{
|
|
types.NewMultiRewardIndex(
|
|
"bnb",
|
|
types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
},
|
|
),
|
|
types.NewMultiRewardIndex(
|
|
"btcb",
|
|
types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
types.NewRewardIndex("ukava", d("0.0")),
|
|
},
|
|
),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"multiple deposit denoms, correct discrete reward denoms",
|
|
args{
|
|
moneyMarketRewardDenoms: standardMoneyMarketRewardDenoms,
|
|
deposit: cs(c("bnb", 1000000000000), c("xrp", 1000000000000)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedClaimSupplyRewardIndexes: types.MultiRewardIndexes{
|
|
types.NewMultiRewardIndex(
|
|
"bnb",
|
|
types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
},
|
|
),
|
|
types.NewMultiRewardIndex(
|
|
"xrp",
|
|
nil,
|
|
),
|
|
},
|
|
},
|
|
},
|
|
}
|
|
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)
|
|
|
|
userAddr := suite.addrs[3]
|
|
|
|
// Prepare money market + reward params
|
|
i := 0
|
|
var multiRewardPeriods types.MultiRewardPeriods
|
|
var rewardPeriods types.RewardPeriods
|
|
for moneyMarketDenom, rewardDenoms := range tc.args.moneyMarketRewardDenoms {
|
|
// Set up multi reward periods for supply/borrow indexes with dynamic money market denoms/reward denoms
|
|
var rewardsPerSecond sdk.Coins
|
|
for _, rewardDenom := range rewardDenoms {
|
|
rewardsPerSecond = append(rewardsPerSecond, sdk.NewCoin(rewardDenom, sdk.OneInt()))
|
|
}
|
|
multiRewardPeriod := types.NewMultiRewardPeriod(true, moneyMarketDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), rewardsPerSecond)
|
|
multiRewardPeriods = append(multiRewardPeriods, multiRewardPeriod)
|
|
|
|
// Set up generic reward periods for usdx minting/delegator indexes
|
|
if i == 0 && len(rewardDenoms) > 0 {
|
|
rewardPeriod := types.NewRewardPeriod(true, moneyMarketDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), rewardsPerSecond[i])
|
|
rewardPeriods = append(rewardPeriods, rewardPeriod)
|
|
i++
|
|
}
|
|
}
|
|
|
|
// Initialize and set incentive params
|
|
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 money market's previous accrual time and supply reward indexes
|
|
for moneyMarketDenom, rewardDenoms := range tc.args.moneyMarketRewardDenoms {
|
|
var rewardIndexes types.RewardIndexes
|
|
for _, rewardDenom := range rewardDenoms {
|
|
rewardIndex := types.NewRewardIndex(rewardDenom, sdk.ZeroDec())
|
|
rewardIndexes = append(rewardIndexes, rewardIndex)
|
|
}
|
|
suite.keeper.SetPreviousHardSupplyRewardAccrualTime(suite.ctx, moneyMarketDenom, tc.args.initialTime)
|
|
if len(rewardIndexes) > 0 {
|
|
suite.keeper.SetHardSupplyRewardIndexes(suite.ctx, moneyMarketDenom, rewardIndexes)
|
|
}
|
|
}
|
|
|
|
// User deposits
|
|
hardKeeper := suite.app.GetHardKeeper()
|
|
err := hardKeeper.Deposit(suite.ctx, userAddr, tc.args.deposit)
|
|
suite.Require().NoError(err)
|
|
|
|
claim, foundClaim := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, userAddr)
|
|
suite.Require().True(foundClaim)
|
|
suite.Require().Equal(tc.args.expectedClaimSupplyRewardIndexes, claim.SupplyRewardIndexes)
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestAccumulateHardSupplyRewards() {
|
|
type args struct {
|
|
deposit sdk.Coin
|
|
rewardsPerSecond sdk.Coins
|
|
initialTime time.Time
|
|
timeElapsed int
|
|
expectedRewardIndexes types.RewardIndexes
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
}
|
|
testCases := []test{
|
|
{
|
|
"single reward denom: 7 seconds",
|
|
args{
|
|
deposit: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 7,
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.000000856478000000"))},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: 1 day",
|
|
args{
|
|
deposit: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 86400,
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.010571385600000000"))},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: 0 seconds",
|
|
args{
|
|
deposit: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 0,
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.0"))},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: 7 seconds",
|
|
args{
|
|
deposit: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 7,
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.000000856478000000")),
|
|
types.NewRewardIndex("ukava", d("0.000000856478000000")),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: 1 day",
|
|
args{
|
|
deposit: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 86400,
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.010571385600000000")),
|
|
types.NewRewardIndex("ukava", d("0.010571385600000000")),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: 0 seconds",
|
|
args{
|
|
deposit: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 0,
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
types.NewRewardIndex("ukava", d("0.0")),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms with different rewards per second: 1 day",
|
|
args{
|
|
deposit: c("bnb", 1000000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 555555)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 86400,
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.010571385600000000")),
|
|
types.NewRewardIndex("ukava", d("0.047999952000000000")),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom, no rewards",
|
|
args{
|
|
deposit: c("bnb", 1000000000000),
|
|
rewardsPerSecond: sdk.Coins{},
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
timeElapsed: 7,
|
|
expectedRewardIndexes: types.RewardIndexes{},
|
|
},
|
|
},
|
|
}
|
|
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), c("hard", 1))},
|
|
types.MultiRewardPeriods{types.NewMultiRewardPeriod(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), tc.args.rewardsPerSecond)},
|
|
types.RewardPeriods{types.NewRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), c("hard", 1))},
|
|
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)
|
|
var rewardIndexes types.RewardIndexes
|
|
for _, rewardCoin := range tc.args.rewardsPerSecond {
|
|
rewardIndex := types.NewRewardIndex(rewardCoin.Denom, sdk.ZeroDec())
|
|
rewardIndexes = append(rewardIndexes, rewardIndex)
|
|
}
|
|
if len(rewardIndexes) > 0 {
|
|
suite.keeper.SetHardSupplyRewardIndexes(suite.ctx, tc.args.deposit.Denom, rewardIndexes)
|
|
}
|
|
|
|
// 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)
|
|
|
|
// Accumulate hard supply rewards for the deposit denom
|
|
multiRewardPeriod, found := suite.keeper.GetHardSupplyRewardPeriods(runCtx, tc.args.deposit.Denom)
|
|
suite.Require().True(found)
|
|
err = suite.keeper.AccumulateHardSupplyRewards(runCtx, multiRewardPeriod)
|
|
suite.Require().NoError(err)
|
|
|
|
// Check that each expected reward index matches the current stored reward index for the denom
|
|
globalRewardIndexes, found := suite.keeper.GetHardSupplyRewardIndexes(runCtx, tc.args.deposit.Denom)
|
|
if len(tc.args.rewardsPerSecond) > 0 {
|
|
suite.Require().True(found)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
globalRewardIndex, found := globalRewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, globalRewardIndex)
|
|
}
|
|
} else {
|
|
suite.Require().False(found)
|
|
}
|
|
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestSynchronizeHardSupplyReward() {
|
|
type args struct {
|
|
incentiveSupplyRewardDenom string
|
|
deposit sdk.Coin
|
|
rewardsPerSecond sdk.Coins
|
|
initialTime time.Time
|
|
blockTimes []int
|
|
expectedRewardIndexes types.RewardIndexes
|
|
expectedRewards sdk.Coins
|
|
updateRewardsViaCommmittee bool
|
|
updatedBaseDenom string
|
|
updatedRewardsPerSecond sdk.Coins
|
|
updatedExpectedRewardIndexes types.RewardIndexes
|
|
updatedExpectedRewards sdk.Coins
|
|
updatedTimeDuration int
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
}
|
|
|
|
testCases := []test{
|
|
{
|
|
"single reward denom: 10 blocks",
|
|
args{
|
|
incentiveSupplyRewardDenom: "bnb",
|
|
deposit: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.001223540000000000"))},
|
|
expectedRewards: cs(c("hard", 12235400)),
|
|
updateRewardsViaCommmittee: false,
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: 10 blocks - long block time",
|
|
args{
|
|
incentiveSupplyRewardDenom: "bnb",
|
|
deposit: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("10.571385600000000000"))},
|
|
expectedRewards: cs(c("hard", 105713856000)),
|
|
updateRewardsViaCommmittee: false,
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: user reward index updated when reward is zero",
|
|
args{
|
|
incentiveSupplyRewardDenom: "ukava",
|
|
deposit: c("ukava", 1),
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.122353998776460010"))},
|
|
expectedRewards: cs(),
|
|
updateRewardsViaCommmittee: false,
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: 10 blocks",
|
|
args{
|
|
incentiveSupplyRewardDenom: "bnb",
|
|
deposit: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 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},
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.001223540000000000")),
|
|
types.NewRewardIndex("ukava", d("0.001223540000000000")),
|
|
},
|
|
expectedRewards: cs(c("hard", 12235400), c("ukava", 12235400)),
|
|
updateRewardsViaCommmittee: false,
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: 10 blocks - long block time",
|
|
args{
|
|
incentiveSupplyRewardDenom: "bnb",
|
|
deposit: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 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},
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("10.571385600000000000")),
|
|
types.NewRewardIndex("ukava", d("10.571385600000000000")),
|
|
},
|
|
expectedRewards: cs(c("hard", 105713856000), c("ukava", 105713856000)),
|
|
updateRewardsViaCommmittee: false,
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms with different rewards per second: 10 blocks",
|
|
args{
|
|
incentiveSupplyRewardDenom: "bnb",
|
|
deposit: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 555555)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.001223540000000000")),
|
|
types.NewRewardIndex("ukava", d("0.005555550000000000")),
|
|
},
|
|
expectedRewards: cs(c("hard", 12235400), c("ukava", 55555500)),
|
|
updateRewardsViaCommmittee: false,
|
|
},
|
|
},
|
|
{
|
|
"denom is in incentive's hard supply reward params but it has no rewards; add reward",
|
|
args{
|
|
incentiveSupplyRewardDenom: "bnb",
|
|
deposit: c("bnb", 10000000000),
|
|
rewardsPerSecond: sdk.Coins{},
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{100},
|
|
expectedRewardIndexes: types.RewardIndexes{},
|
|
expectedRewards: sdk.Coins{},
|
|
updateRewardsViaCommmittee: true,
|
|
updatedBaseDenom: "bnb",
|
|
updatedRewardsPerSecond: cs(c("hard", 100000)),
|
|
updatedExpectedRewards: cs(c("hard", 8640000000)),
|
|
updatedExpectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.864")),
|
|
},
|
|
updatedTimeDuration: 86400,
|
|
},
|
|
},
|
|
{
|
|
"denom is in incentive's hard supply reward params and has rewards; add new reward type",
|
|
args{
|
|
incentiveSupplyRewardDenom: "bnb",
|
|
deposit: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{86400},
|
|
expectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("1.057138560000000000")),
|
|
},
|
|
expectedRewards: cs(c("hard", 10571385600)),
|
|
updateRewardsViaCommmittee: true,
|
|
updatedBaseDenom: "bnb",
|
|
updatedRewardsPerSecond: cs(c("hard", 122354), c("ukava", 100000)),
|
|
updatedExpectedRewards: cs(c("hard", 21142771200), c("ukava", 8640000000)),
|
|
updatedExpectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("2.114277120000000000")),
|
|
types.NewRewardIndex("ukava", d("0.864000000000000000")),
|
|
},
|
|
updatedTimeDuration: 86400,
|
|
},
|
|
},
|
|
{
|
|
"denom is in hard's money market params but not in incentive's hard supply reward params; add reward",
|
|
args{
|
|
incentiveSupplyRewardDenom: "bnb",
|
|
deposit: c("zzz", 10000000000),
|
|
rewardsPerSecond: sdk.Coins{},
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{100},
|
|
expectedRewardIndexes: types.RewardIndexes{},
|
|
expectedRewards: sdk.Coins{},
|
|
updateRewardsViaCommmittee: true,
|
|
updatedBaseDenom: "zzz",
|
|
updatedRewardsPerSecond: cs(c("hard", 100000)),
|
|
updatedExpectedRewards: cs(c("hard", 8640000000)),
|
|
updatedExpectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.864")),
|
|
},
|
|
updatedTimeDuration: 86400,
|
|
},
|
|
},
|
|
{
|
|
"denom incentive's hard supply reward params but it has no rewards; add multiple reward types",
|
|
args{
|
|
incentiveSupplyRewardDenom: "bnb",
|
|
deposit: c("bnb", 10000000000),
|
|
rewardsPerSecond: sdk.Coins{},
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{100},
|
|
expectedRewardIndexes: types.RewardIndexes{},
|
|
expectedRewards: sdk.Coins{},
|
|
updateRewardsViaCommmittee: true,
|
|
updatedBaseDenom: "bnb",
|
|
updatedRewardsPerSecond: cs(c("hard", 100000), c("ukava", 100500), c("swap", 500)),
|
|
updatedExpectedRewards: cs(c("hard", 8640000000), c("ukava", 8683200000), c("swap", 43200000)),
|
|
updatedExpectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.864")),
|
|
types.NewRewardIndex("ukava", d("0.86832")),
|
|
types.NewRewardIndex("swap", d("0.00432")),
|
|
},
|
|
updatedTimeDuration: 86400,
|
|
},
|
|
},
|
|
{
|
|
"denom is in hard's money market params but not in incentive's hard supply reward params; add multiple reward types",
|
|
args{
|
|
incentiveSupplyRewardDenom: "bnb",
|
|
deposit: c("zzz", 10000000000),
|
|
rewardsPerSecond: sdk.Coins{},
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
blockTimes: []int{100},
|
|
expectedRewardIndexes: types.RewardIndexes{},
|
|
expectedRewards: sdk.Coins{},
|
|
updateRewardsViaCommmittee: true,
|
|
updatedBaseDenom: "zzz",
|
|
updatedRewardsPerSecond: cs(c("hard", 100000), c("ukava", 100500), c("swap", 500)),
|
|
updatedExpectedRewards: cs(c("hard", 8640000000), c("ukava", 8683200000), c("swap", 43200000)),
|
|
updatedExpectedRewardIndexes: types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.864")),
|
|
types.NewRewardIndex("ukava", d("0.86832")),
|
|
types.NewRewardIndex("swap", d("0.00432")),
|
|
},
|
|
updatedTimeDuration: 86400,
|
|
},
|
|
},
|
|
}
|
|
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
|
|
incentiveParams := types.NewParams(
|
|
types.RewardPeriods{types.NewRewardPeriod(true, tc.args.incentiveSupplyRewardDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), c("hard", 1))},
|
|
types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.incentiveSupplyRewardDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)},
|
|
types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.incentiveSupplyRewardDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)},
|
|
types.RewardPeriods{types.NewRewardPeriod(true, tc.args.incentiveSupplyRewardDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), c("hard", 1))},
|
|
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, incentiveParams)
|
|
suite.keeper.SetPreviousHardSupplyRewardAccrualTime(suite.ctx, tc.args.incentiveSupplyRewardDenom, tc.args.initialTime)
|
|
var rewardIndexes types.RewardIndexes
|
|
for _, rewardCoin := range tc.args.rewardsPerSecond {
|
|
rewardIndex := types.NewRewardIndex(rewardCoin.Denom, sdk.ZeroDec())
|
|
rewardIndexes = append(rewardIndexes, rewardIndex)
|
|
}
|
|
if len(rewardIndexes) > 0 {
|
|
suite.keeper.SetHardSupplyRewardIndexes(suite.ctx, tc.args.incentiveSupplyRewardDenom, rewardIndexes)
|
|
}
|
|
|
|
// Set up hard state (interest factor for the relevant denom)
|
|
suite.hardKeeper.SetSupplyInterestFactor(suite.ctx, tc.args.incentiveSupplyRewardDenom, sdk.MustNewDecFromStr("1.0"))
|
|
suite.hardKeeper.SetBorrowInterestFactor(suite.ctx, tc.args.incentiveSupplyRewardDenom, sdk.MustNewDecFromStr("1.0"))
|
|
suite.hardKeeper.SetPreviousAccrualTime(suite.ctx, tc.args.incentiveSupplyRewardDenom, tc.args.initialTime)
|
|
|
|
// Deposit a fixed amount from another user to dilute primary user's rewards per second.
|
|
suite.Require().NoError(
|
|
suite.hardKeeper.Deposit(suite.ctx, suite.addrs[2], cs(c("ukava", 100_000_000))),
|
|
)
|
|
|
|
// 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 with 0 reward indexes
|
|
claim, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, userAddr)
|
|
suite.Require().True(found)
|
|
multiRewardIndex, _ := claim.SupplyRewardIndexes.GetRewardIndex(tc.args.deposit.Denom)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
currRewardIndex, found := multiRewardIndex.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(sdk.ZeroDec(), currRewardIndex.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)
|
|
|
|
// Accumulate hard supply-side rewards
|
|
multiRewardPeriod, found := suite.keeper.GetHardSupplyRewardPeriods(blockCtx, tc.args.deposit.Denom)
|
|
if found {
|
|
err := suite.keeper.AccumulateHardSupplyRewards(blockCtx, multiRewardPeriod)
|
|
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, userAddr)
|
|
suite.Require().True(found)
|
|
suite.Require().NotPanics(func() {
|
|
suite.keeper.SynchronizeHardSupplyReward(suite.ctx, deposit)
|
|
})
|
|
|
|
// Check that the global reward index's reward factor and user's claim have been updated as expected
|
|
claim, found = suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, userAddr)
|
|
suite.Require().True(found)
|
|
globalRewardIndexes, foundGlobalRewardIndexes := suite.keeper.GetHardSupplyRewardIndexes(suite.ctx, tc.args.deposit.Denom)
|
|
if len(tc.args.rewardsPerSecond) > 0 {
|
|
suite.Require().True(foundGlobalRewardIndexes)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
// Check that global reward index has been updated as expected
|
|
globalRewardIndex, found := globalRewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, globalRewardIndex)
|
|
|
|
// Check that the user's claim's reward index matches the corresponding global reward index
|
|
multiRewardIndex, found := claim.SupplyRewardIndexes.GetRewardIndex(tc.args.deposit.Denom)
|
|
suite.Require().True(found)
|
|
rewardIndex, found := multiRewardIndex.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, rewardIndex)
|
|
|
|
// Check that the user's claim holds the expected amount of reward coins
|
|
suite.Require().Equal(
|
|
tc.args.expectedRewards.AmountOf(expectedRewardIndex.CollateralType),
|
|
claim.Reward.AmountOf(expectedRewardIndex.CollateralType),
|
|
)
|
|
}
|
|
}
|
|
|
|
// Only test cases with reward param updates continue past this point
|
|
if !tc.args.updateRewardsViaCommmittee {
|
|
return
|
|
}
|
|
|
|
// If are no initial rewards per second, add new rewards through a committee param change
|
|
// 1. Construct incentive's new HardSupplyRewardPeriods param
|
|
currIncentiveHardSupplyRewardPeriods := suite.keeper.GetParams(suite.ctx).HardSupplyRewardPeriods
|
|
multiRewardPeriod, found := currIncentiveHardSupplyRewardPeriods.GetMultiRewardPeriod(tc.args.deposit.Denom)
|
|
if found {
|
|
// Deposit denom's reward period exists, but it doesn't have any rewards per second
|
|
index, found := currIncentiveHardSupplyRewardPeriods.GetMultiRewardPeriodIndex(tc.args.deposit.Denom)
|
|
suite.Require().True(found)
|
|
multiRewardPeriod.RewardsPerSecond = tc.args.updatedRewardsPerSecond
|
|
currIncentiveHardSupplyRewardPeriods[index] = multiRewardPeriod
|
|
} else {
|
|
// Deposit denom's reward period does not exist
|
|
_, found := currIncentiveHardSupplyRewardPeriods.GetMultiRewardPeriodIndex(tc.args.deposit.Denom)
|
|
suite.Require().False(found)
|
|
newMultiRewardPeriod := types.NewMultiRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.updatedRewardsPerSecond)
|
|
currIncentiveHardSupplyRewardPeriods = append(currIncentiveHardSupplyRewardPeriods, newMultiRewardPeriod)
|
|
}
|
|
|
|
// 2. Construct the parameter change proposal to update HardSupplyRewardPeriods param
|
|
pubProposal := params.NewParameterChangeProposal(
|
|
"Update hard supply rewards", "Adds a new reward coin to the incentive module's hard supply rewards.",
|
|
[]params.ParamChange{
|
|
{
|
|
Subspace: types.ModuleName, // target incentive module
|
|
Key: string(types.KeyHardSupplyRewardPeriods), // target hard supply rewards key
|
|
Value: string(suite.app.Codec().MustMarshalJSON(currIncentiveHardSupplyRewardPeriods)),
|
|
},
|
|
},
|
|
)
|
|
|
|
// 3. Ensure proposal is properly formed
|
|
err = suite.committeeKeeper.ValidatePubProposal(suite.ctx, pubProposal)
|
|
suite.Require().NoError(err)
|
|
|
|
// 4. Committee creates proposal
|
|
committeeMemberOne := suite.addrs[0]
|
|
committeeMemberTwo := suite.addrs[1]
|
|
proposalID, err := suite.committeeKeeper.SubmitProposal(suite.ctx, committeeMemberOne, 1, pubProposal)
|
|
suite.Require().NoError(err)
|
|
|
|
// 5. Committee votes and passes proposal
|
|
err = suite.committeeKeeper.AddVote(suite.ctx, proposalID, committeeMemberOne)
|
|
err = suite.committeeKeeper.AddVote(suite.ctx, proposalID, committeeMemberTwo)
|
|
|
|
// 6. Check proposal passed
|
|
proposalPasses, err := suite.committeeKeeper.GetProposalResult(suite.ctx, proposalID)
|
|
suite.Require().NoError(err)
|
|
suite.Require().True(proposalPasses)
|
|
|
|
// 7. Run committee module's begin blocker to enact proposal
|
|
suite.NotPanics(func() {
|
|
committee.BeginBlocker(suite.ctx, abci.RequestBeginBlock{}, suite.committeeKeeper)
|
|
})
|
|
|
|
// We need to accumulate hard supply-side rewards again
|
|
multiRewardPeriod, found = suite.keeper.GetHardSupplyRewardPeriods(suite.ctx, tc.args.deposit.Denom)
|
|
suite.Require().True(found)
|
|
|
|
// But new deposit denoms don't have their PreviousHardSupplyRewardAccrualTime set yet,
|
|
// so we need to call the accumulation method once to set the initial reward accrual time
|
|
if tc.args.deposit.Denom != tc.args.incentiveSupplyRewardDenom {
|
|
err = suite.keeper.AccumulateHardSupplyRewards(suite.ctx, multiRewardPeriod)
|
|
suite.Require().NoError(err)
|
|
}
|
|
|
|
// Now we can jump forward in time and accumulate rewards
|
|
updatedBlockTime = previousBlockTime.Add(time.Duration(int(time.Second) * tc.args.updatedTimeDuration))
|
|
suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime)
|
|
err = suite.keeper.AccumulateHardSupplyRewards(suite.ctx, multiRewardPeriod)
|
|
suite.Require().NoError(err)
|
|
|
|
// After we've accumulated, run synchronize
|
|
deposit, found = hardKeeper.GetDeposit(suite.ctx, userAddr)
|
|
suite.Require().True(found)
|
|
suite.Require().NotPanics(func() {
|
|
suite.keeper.SynchronizeHardSupplyReward(suite.ctx, deposit)
|
|
})
|
|
|
|
// Check that the global reward index's reward factor and user's claim have been updated as expected
|
|
globalRewardIndexes, found = suite.keeper.GetHardSupplyRewardIndexes(suite.ctx, tc.args.deposit.Denom)
|
|
suite.Require().True(found)
|
|
claim, found = suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, userAddr)
|
|
suite.Require().True(found)
|
|
for _, expectedRewardIndex := range tc.args.updatedExpectedRewardIndexes {
|
|
// Check that global reward index has been updated as expected
|
|
globalRewardIndex, found := globalRewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, globalRewardIndex)
|
|
|
|
// Check that the user's claim's reward index matches the corresponding global reward index
|
|
multiRewardIndex, found := claim.SupplyRewardIndexes.GetRewardIndex(tc.args.deposit.Denom)
|
|
suite.Require().True(found)
|
|
rewardIndex, found := multiRewardIndex.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, rewardIndex)
|
|
|
|
// Check that the user's claim holds the expected amount of reward coins
|
|
suite.Require().Equal(
|
|
tc.args.updatedExpectedRewards.AmountOf(expectedRewardIndex.CollateralType),
|
|
claim.Reward.AmountOf(expectedRewardIndex.CollateralType),
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestUpdateHardSupplyIndexDenoms() {
|
|
type depositModification struct {
|
|
coins sdk.Coins
|
|
withdraw bool
|
|
}
|
|
|
|
type args struct {
|
|
firstDeposit sdk.Coins
|
|
modification depositModification
|
|
rewardsPerSecond sdk.Coins
|
|
initialTime time.Time
|
|
expectedSupplyIndexDenoms []string
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
}
|
|
|
|
testCases := []test{
|
|
{
|
|
"single reward denom: update adds one supply reward index",
|
|
args{
|
|
firstDeposit: cs(c("bnb", 10000000000)),
|
|
modification: depositModification{coins: cs(c("ukava", 10000000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedSupplyIndexDenoms: []string{"bnb", "ukava"},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: update adds multiple supply reward indexes",
|
|
args{
|
|
firstDeposit: cs(c("bnb", 10000000000)),
|
|
modification: depositModification{coins: cs(c("ukava", 10000000000), c("btcb", 10000000000), c("xrp", 10000000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedSupplyIndexDenoms: []string{"bnb", "ukava", "btcb", "xrp"},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: update doesn't add duplicate supply reward index for same denom",
|
|
args{
|
|
firstDeposit: cs(c("bnb", 10000000000)),
|
|
modification: depositModification{coins: cs(c("bnb", 5000000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedSupplyIndexDenoms: []string{"bnb"},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: update adds one supply reward index",
|
|
args{
|
|
firstDeposit: cs(c("bnb", 10000000000)),
|
|
modification: depositModification{coins: cs(c("ukava", 10000000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedSupplyIndexDenoms: []string{"bnb", "ukava"},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: update adds multiple supply reward indexes",
|
|
args{
|
|
firstDeposit: cs(c("bnb", 10000000000)),
|
|
modification: depositModification{coins: cs(c("ukava", 10000000000), c("btcb", 10000000000), c("xrp", 10000000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedSupplyIndexDenoms: []string{"bnb", "ukava", "btcb", "xrp"},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: update doesn't add duplicate supply reward index for same denom",
|
|
args{
|
|
firstDeposit: cs(c("bnb", 10000000000)),
|
|
modification: depositModification{coins: cs(c("bnb", 5000000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedSupplyIndexDenoms: []string{"bnb"},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: fully withdrawing a denom deletes the denom's supply reward index",
|
|
args{
|
|
firstDeposit: cs(c("bnb", 1000000000)),
|
|
modification: depositModification{coins: cs(c("bnb", 1100000000)), withdraw: true},
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedSupplyIndexDenoms: []string{},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: fully withdrawing a denom deletes only the denom's supply reward index",
|
|
args{
|
|
firstDeposit: cs(c("bnb", 1000000000), c("ukava", 100000000)),
|
|
modification: depositModification{coins: cs(c("bnb", 1100000000)), withdraw: true},
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedSupplyIndexDenoms: []string{"ukava"},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: fully repaying a denom deletes the denom's supply reward index",
|
|
args{
|
|
firstDeposit: cs(c("bnb", 1000000000)),
|
|
modification: depositModification{coins: cs(c("bnb", 1100000000)), withdraw: true},
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedSupplyIndexDenoms: []string{},
|
|
},
|
|
},
|
|
}
|
|
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 i, denom := range tc.args.expectedSupplyIndexDenoms {
|
|
// Create just one reward period for USDX Minting / Hard Delegator reward periods (otherwise params will panic on duplicate)
|
|
if i == 0 {
|
|
rewardPeriod := types.NewRewardPeriod(true, denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond[i])
|
|
rewardPeriods = append(rewardPeriods, rewardPeriod)
|
|
}
|
|
multiRewardPeriod := types.NewMultiRewardPeriod(true, denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), 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
|
|
var rewardIndexes types.RewardIndexes
|
|
for _, rewardCoin := range tc.args.rewardsPerSecond {
|
|
rewardIndex := types.NewRewardIndex(rewardCoin.Denom, sdk.ZeroDec())
|
|
rewardIndexes = append(rewardIndexes, rewardIndex)
|
|
}
|
|
for _, denom := range tc.args.expectedSupplyIndexDenoms {
|
|
suite.keeper.SetPreviousHardSupplyRewardAccrualTime(suite.ctx, denom, tc.args.initialTime)
|
|
suite.keeper.SetHardSupplyRewardIndexes(suite.ctx, denom, rewardIndexes)
|
|
}
|
|
|
|
// 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 modifies their Deposit by withdrawing or depositing more
|
|
if tc.args.modification.withdraw {
|
|
err = hardKeeper.Withdraw(suite.ctx, userAddr, tc.args.modification.coins)
|
|
} else {
|
|
err = hardKeeper.Deposit(suite.ctx, userAddr, tc.args.modification.coins)
|
|
}
|
|
suite.Require().NoError(err)
|
|
|
|
// Confirm that the claim contains all expected supply indexes
|
|
claimAfterModification, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3])
|
|
suite.Require().True(found)
|
|
for _, denom := range tc.args.expectedSupplyIndexDenoms {
|
|
_, hasIndex := claimAfterModification.HasSupplyRewardIndex(denom)
|
|
suite.Require().True(hasIndex)
|
|
}
|
|
suite.Require().True(len(claimAfterModification.SupplyRewardIndexes) == len(tc.args.expectedSupplyIndexDenoms))
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestInitializeHardBorrowRewards() {
|
|
|
|
type args struct {
|
|
moneyMarketRewardDenoms map[string][]string
|
|
deposit sdk.Coins
|
|
borrow sdk.Coins
|
|
initialTime time.Time
|
|
expectedClaimBorrowRewardIndexes types.MultiRewardIndexes
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
}
|
|
|
|
standardMoneyMarketRewardDenoms := map[string][]string{
|
|
"bnb": {"hard"},
|
|
"btcb": {"hard", "ukava"},
|
|
"xrp": {},
|
|
}
|
|
|
|
testCases := []test{
|
|
{
|
|
"single deposit denom, single reward denom",
|
|
args{
|
|
moneyMarketRewardDenoms: standardMoneyMarketRewardDenoms,
|
|
deposit: cs(c("bnb", 1000000000000)),
|
|
borrow: cs(c("bnb", 100000000000)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedClaimBorrowRewardIndexes: types.MultiRewardIndexes{
|
|
types.NewMultiRewardIndex(
|
|
"bnb",
|
|
types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
},
|
|
),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"single deposit denom, multiple reward denoms",
|
|
args{
|
|
moneyMarketRewardDenoms: standardMoneyMarketRewardDenoms,
|
|
deposit: cs(c("btcb", 1000000000000)),
|
|
borrow: cs(c("btcb", 100000000000)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedClaimBorrowRewardIndexes: types.MultiRewardIndexes{
|
|
types.NewMultiRewardIndex(
|
|
"btcb",
|
|
types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
types.NewRewardIndex("ukava", d("0.0")),
|
|
},
|
|
),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"single deposit denom, no reward denoms",
|
|
args{
|
|
moneyMarketRewardDenoms: standardMoneyMarketRewardDenoms,
|
|
deposit: cs(c("xrp", 1000000000000)),
|
|
borrow: cs(c("xrp", 100000000000)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedClaimBorrowRewardIndexes: types.MultiRewardIndexes{
|
|
types.NewMultiRewardIndex(
|
|
"xrp",
|
|
nil,
|
|
),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"multiple deposit denoms, multiple overlapping reward denoms",
|
|
args{
|
|
moneyMarketRewardDenoms: standardMoneyMarketRewardDenoms,
|
|
deposit: cs(c("bnb", 1000000000000), c("btcb", 1000000000000)),
|
|
borrow: cs(c("bnb", 100000000000), c("btcb", 100000000000)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedClaimBorrowRewardIndexes: types.MultiRewardIndexes{
|
|
types.NewMultiRewardIndex(
|
|
"bnb",
|
|
types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
},
|
|
),
|
|
types.NewMultiRewardIndex(
|
|
"btcb",
|
|
types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
types.NewRewardIndex("ukava", d("0.0")),
|
|
},
|
|
),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"multiple deposit denoms, correct discrete reward denoms",
|
|
args{
|
|
moneyMarketRewardDenoms: standardMoneyMarketRewardDenoms,
|
|
deposit: cs(c("bnb", 1000000000000), c("xrp", 1000000000000)),
|
|
borrow: cs(c("bnb", 100000000000), c("xrp", 100000000000)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedClaimBorrowRewardIndexes: types.MultiRewardIndexes{
|
|
types.NewMultiRewardIndex(
|
|
"bnb",
|
|
types.RewardIndexes{
|
|
types.NewRewardIndex("hard", d("0.0")),
|
|
},
|
|
),
|
|
types.NewMultiRewardIndex(
|
|
"xrp",
|
|
nil,
|
|
),
|
|
},
|
|
},
|
|
},
|
|
}
|
|
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)
|
|
|
|
userAddr := suite.addrs[3]
|
|
|
|
// Prepare money market + reward params
|
|
i := 0
|
|
var multiRewardPeriods types.MultiRewardPeriods
|
|
var rewardPeriods types.RewardPeriods
|
|
for moneyMarketDenom, rewardDenoms := range tc.args.moneyMarketRewardDenoms {
|
|
// Set up multi reward periods for supply/borrow indexes with dynamic money market denoms/reward denoms
|
|
var rewardsPerSecond sdk.Coins
|
|
for _, rewardDenom := range rewardDenoms {
|
|
rewardsPerSecond = append(rewardsPerSecond, sdk.NewCoin(rewardDenom, sdk.OneInt()))
|
|
}
|
|
multiRewardPeriod := types.NewMultiRewardPeriod(true, moneyMarketDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), rewardsPerSecond)
|
|
multiRewardPeriods = append(multiRewardPeriods, multiRewardPeriod)
|
|
|
|
// Set up generic reward periods for usdx minting/delegator indexes
|
|
if i == 0 && len(rewardDenoms) > 0 {
|
|
rewardPeriod := types.NewRewardPeriod(true, moneyMarketDenom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), rewardsPerSecond[i])
|
|
rewardPeriods = append(rewardPeriods, rewardPeriod)
|
|
i++
|
|
}
|
|
}
|
|
|
|
// Initialize and set incentive params
|
|
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 money market's previous accrual time and supply reward indexes
|
|
for moneyMarketDenom, rewardDenoms := range tc.args.moneyMarketRewardDenoms {
|
|
var rewardIndexes types.RewardIndexes
|
|
for _, rewardDenom := range rewardDenoms {
|
|
rewardIndex := types.NewRewardIndex(rewardDenom, sdk.ZeroDec())
|
|
rewardIndexes = append(rewardIndexes, rewardIndex)
|
|
}
|
|
suite.keeper.SetPreviousHardBorrowRewardAccrualTime(suite.ctx, moneyMarketDenom, tc.args.initialTime)
|
|
if len(rewardIndexes) > 0 {
|
|
suite.keeper.SetHardBorrowRewardIndexes(suite.ctx, moneyMarketDenom, rewardIndexes)
|
|
}
|
|
}
|
|
|
|
hardKeeper := suite.app.GetHardKeeper()
|
|
// User deposits
|
|
err := hardKeeper.Deposit(suite.ctx, userAddr, tc.args.deposit)
|
|
suite.Require().NoError(err)
|
|
// User borrows
|
|
err = hardKeeper.Borrow(suite.ctx, userAddr, tc.args.borrow)
|
|
suite.Require().NoError(err)
|
|
|
|
claim, foundClaim := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, userAddr)
|
|
suite.Require().True(foundClaim)
|
|
suite.Require().Equal(tc.args.expectedClaimBorrowRewardIndexes, claim.BorrowRewardIndexes)
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestUpdateHardBorrowIndexDenoms() {
|
|
type withdrawModification struct {
|
|
coins sdk.Coins
|
|
repay bool
|
|
}
|
|
|
|
type args struct {
|
|
initialDeposit sdk.Coins
|
|
firstBorrow sdk.Coins
|
|
modification withdrawModification
|
|
rewardsPerSecond sdk.Coins
|
|
initialTime time.Time
|
|
expectedBorrowIndexDenoms []string
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
}
|
|
|
|
testCases := []test{
|
|
{
|
|
"single reward denom: update adds one borrow reward index",
|
|
args{
|
|
initialDeposit: cs(c("bnb", 10000000000)),
|
|
firstBorrow: cs(c("bnb", 50000000)),
|
|
modification: withdrawModification{coins: cs(c("ukava", 500000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedBorrowIndexDenoms: []string{"bnb", "ukava"},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: update adds multiple borrow supply reward indexes",
|
|
args{
|
|
initialDeposit: cs(c("btcb", 10000000000)),
|
|
firstBorrow: cs(c("btcb", 50000000)),
|
|
modification: withdrawModification{coins: cs(c("ukava", 500000000), c("bnb", 50000000000), c("xrp", 50000000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedBorrowIndexDenoms: []string{"btcb", "ukava", "bnb", "xrp"},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: update doesn't add duplicate borrow reward index for same denom",
|
|
args{
|
|
initialDeposit: cs(c("bnb", 100000000000)),
|
|
firstBorrow: cs(c("bnb", 50000000)),
|
|
modification: withdrawModification{coins: cs(c("bnb", 50000000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedBorrowIndexDenoms: []string{"bnb"},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: update adds one borrow reward index",
|
|
args{
|
|
initialDeposit: cs(c("bnb", 10000000000)),
|
|
firstBorrow: cs(c("bnb", 50000000)),
|
|
modification: withdrawModification{coins: cs(c("ukava", 500000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedBorrowIndexDenoms: []string{"bnb", "ukava"},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: update adds multiple borrow supply reward indexes",
|
|
args{
|
|
initialDeposit: cs(c("btcb", 10000000000)),
|
|
firstBorrow: cs(c("btcb", 50000000)),
|
|
modification: withdrawModification{coins: cs(c("ukava", 500000000), c("bnb", 50000000000), c("xrp", 50000000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedBorrowIndexDenoms: []string{"btcb", "ukava", "bnb", "xrp"},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: update doesn't add duplicate borrow reward index for same denom",
|
|
args{
|
|
initialDeposit: cs(c("bnb", 100000000000)),
|
|
firstBorrow: cs(c("bnb", 50000000)),
|
|
modification: withdrawModification{coins: cs(c("bnb", 50000000000))},
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedBorrowIndexDenoms: []string{"bnb"},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: fully repaying a denom deletes the denom's supply reward index",
|
|
args{
|
|
initialDeposit: cs(c("bnb", 1000000000)),
|
|
firstBorrow: cs(c("bnb", 100000000)),
|
|
modification: withdrawModification{coins: cs(c("bnb", 1100000000)), repay: true},
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedBorrowIndexDenoms: []string{},
|
|
},
|
|
},
|
|
{
|
|
"single reward denom: fully repaying a denom deletes only the denom's supply reward index",
|
|
args{
|
|
initialDeposit: cs(c("bnb", 1000000000)),
|
|
firstBorrow: cs(c("bnb", 100000000), c("ukava", 10000000)),
|
|
modification: withdrawModification{coins: cs(c("bnb", 1100000000)), repay: true},
|
|
rewardsPerSecond: cs(c("hard", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedBorrowIndexDenoms: []string{"ukava"},
|
|
},
|
|
},
|
|
{
|
|
"multiple reward denoms: fully repaying a denom deletes the denom's supply reward index",
|
|
args{
|
|
initialDeposit: cs(c("bnb", 1000000000)),
|
|
firstBorrow: cs(c("bnb", 100000000), c("ukava", 10000000)),
|
|
modification: withdrawModification{coins: cs(c("bnb", 1100000000)), repay: true},
|
|
rewardsPerSecond: cs(c("hard", 122354), c("ukava", 122354)),
|
|
initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
expectedBorrowIndexDenoms: []string{"ukava"},
|
|
},
|
|
},
|
|
}
|
|
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.modification.coins...)
|
|
supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins)
|
|
|
|
// Set up generic reward periods
|
|
var multiRewardPeriods types.MultiRewardPeriods
|
|
var rewardPeriods types.RewardPeriods
|
|
for i, denom := range tc.args.expectedBorrowIndexDenoms {
|
|
// Create just one reward period for USDX Minting / Hard Delegator reward periods (otherwise params will panic on duplicate)
|
|
if i == 0 {
|
|
rewardPeriod := types.NewRewardPeriod(true, denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond[i])
|
|
rewardPeriods = append(rewardPeriods, rewardPeriod)
|
|
}
|
|
multiRewardPeriod := types.NewMultiRewardPeriod(true, denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), 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 expected borrow denom's previous accrual time and borrow reward factor
|
|
var rewardIndexes types.RewardIndexes
|
|
for _, rewardCoin := range tc.args.rewardsPerSecond {
|
|
rewardIndex := types.NewRewardIndex(rewardCoin.Denom, sdk.ZeroDec())
|
|
rewardIndexes = append(rewardIndexes, rewardIndex)
|
|
}
|
|
for _, denom := range tc.args.expectedBorrowIndexDenoms {
|
|
suite.keeper.SetPreviousHardSupplyRewardAccrualTime(suite.ctx, denom, tc.args.initialTime)
|
|
suite.keeper.SetHardBorrowRewardIndexes(suite.ctx, denom, rewardIndexes)
|
|
}
|
|
|
|
// 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 modifies their Borrow by either repaying or borrowing more
|
|
if tc.args.modification.repay {
|
|
err = hardKeeper.Repay(suite.ctx, userAddr, userAddr, tc.args.modification.coins)
|
|
} else {
|
|
err = hardKeeper.Borrow(suite.ctx, userAddr, tc.args.modification.coins)
|
|
}
|
|
suite.Require().NoError(err)
|
|
|
|
// Confirm that claim's borrow reward indexes contain expected values
|
|
claimAfterModification, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3])
|
|
suite.Require().True(found)
|
|
for _, coin := range tc.args.modification.coins {
|
|
_, hasIndex := claimAfterModification.HasBorrowRewardIndex(coin.Denom)
|
|
if tc.args.modification.repay {
|
|
// Only false if denom is repaid in full
|
|
if tc.args.modification.coins.AmountOf(coin.Denom).GTE(tc.args.firstBorrow.AmountOf(coin.Denom)) {
|
|
suite.Require().False(hasIndex)
|
|
}
|
|
} else {
|
|
suite.Require().True(hasIndex)
|
|
}
|
|
}
|
|
suite.Require().True(len(claimAfterModification.BorrowRewardIndexes) == len(tc.args.expectedBorrowIndexDenoms))
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestSynchronizeHardDelegatorReward() {
|
|
type args struct {
|
|
delegation sdk.Coin
|
|
rewardsPerSecond sdk.Coin
|
|
initialTime time.Time
|
|
blockTimes []int
|
|
expectedRewardFactor sdk.Dec
|
|
expectedRewards sdk.Coins
|
|
}
|
|
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: cs(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: cs(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.Coins
|
|
initialTime time.Time
|
|
blockTimes []int
|
|
expectedRewardIndexes types.RewardIndexes
|
|
expectedRewards sdk.Coins
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
}
|
|
|
|
testCases := []test{
|
|
{
|
|
"10 blocks",
|
|
args{
|
|
deposit: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.001223540000000000"))},
|
|
expectedRewards: cs(c("hard", 12235400)),
|
|
},
|
|
},
|
|
{
|
|
"10 blocks - long block time",
|
|
args{
|
|
deposit: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("10.571385600000000000"))},
|
|
expectedRewards: cs(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)
|
|
|
|
// 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[0])},
|
|
types.MultiRewardPeriods{types.NewMultiRewardPeriod(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), 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[0])},
|
|
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)
|
|
var rewardIndexes types.RewardIndexes
|
|
for _, rewardCoin := range tc.args.rewardsPerSecond {
|
|
rewardIndex := types.NewRewardIndex(rewardCoin.Denom, sdk.ZeroDec())
|
|
rewardIndexes = append(rewardIndexes, rewardIndex)
|
|
}
|
|
suite.keeper.SetHardSupplyRewardIndexes(suite.ctx, tc.args.deposit.Denom, rewardIndexes)
|
|
|
|
// 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 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)
|
|
multiRewardIndex, _ := claim.SupplyRewardIndexes.GetRewardIndex(tc.args.deposit.Denom)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
currRewardIndex, found := multiRewardIndex.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(sdk.ZeroDec(), currRewardIndex.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)
|
|
|
|
// Accumulate hard supply-side rewards
|
|
multiRewardPeriod, found := suite.keeper.GetHardSupplyRewardPeriods(blockCtx, tc.args.deposit.Denom)
|
|
suite.Require().True(found)
|
|
err := suite.keeper.AccumulateHardSupplyRewards(blockCtx, multiRewardPeriod)
|
|
suite.Require().NoError(err)
|
|
}
|
|
updatedBlockTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * timeElapsed))
|
|
suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime)
|
|
|
|
// Confirm that the user's claim hasn't been synced
|
|
claimPre, foundPre := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3])
|
|
suite.Require().True(foundPre)
|
|
multiRewardIndexPre, _ := claimPre.SupplyRewardIndexes.GetRewardIndex(tc.args.deposit.Denom)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
currRewardIndex, found := multiRewardIndexPre.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(sdk.ZeroDec(), currRewardIndex.RewardFactor)
|
|
}
|
|
|
|
// Check that the synced claim held in memory has properly simulated syncing
|
|
syncedClaim := suite.keeper.SimulateHardSynchronization(suite.ctx, claimPre)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
// Check that the user's claim's reward index matches the expected reward index
|
|
multiRewardIndex, found := syncedClaim.SupplyRewardIndexes.GetRewardIndex(tc.args.deposit.Denom)
|
|
suite.Require().True(found)
|
|
rewardIndex, found := multiRewardIndex.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, rewardIndex)
|
|
|
|
// Check that the user's claim holds the expected amount of reward coins
|
|
suite.Require().Equal(
|
|
tc.args.expectedRewards.AmountOf(expectedRewardIndex.CollateralType),
|
|
syncedClaim.Reward.AmountOf(expectedRewardIndex.CollateralType),
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestSimulateHardBorrowRewardSynchronization() {
|
|
type args struct {
|
|
borrow sdk.Coin
|
|
rewardsPerSecond sdk.Coins
|
|
initialTime time.Time
|
|
blockTimes []int
|
|
expectedRewardIndexes types.RewardIndexes
|
|
expectedRewards sdk.Coins
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
}
|
|
|
|
testCases := []test{
|
|
{
|
|
"10 blocks",
|
|
args{
|
|
borrow: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("0.001223540000173228"))},
|
|
expectedRewards: cs(c("hard", 12235400)),
|
|
},
|
|
},
|
|
{
|
|
"10 blocks - long block time",
|
|
args{
|
|
borrow: c("bnb", 10000000000),
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("hard", d("10.571385603126235340"))},
|
|
expectedRewards: cs(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[0])},
|
|
types.MultiRewardPeriods{types.NewMultiRewardPeriod(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), 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[0])},
|
|
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)
|
|
var rewardIndexes types.RewardIndexes
|
|
for _, rewardCoin := range tc.args.rewardsPerSecond {
|
|
rewardIndex := types.NewRewardIndex(rewardCoin.Denom, sdk.ZeroDec())
|
|
rewardIndexes = append(rewardIndexes, rewardIndex)
|
|
}
|
|
suite.keeper.SetHardBorrowRewardIndexes(suite.ctx, tc.args.borrow.Denom, rewardIndexes)
|
|
|
|
// 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)
|
|
multiRewardIndex, _ := claim.BorrowRewardIndexes.GetRewardIndex(tc.args.borrow.Denom)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
currRewardIndex, found := multiRewardIndex.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(sdk.ZeroDec(), currRewardIndex.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)
|
|
|
|
// Accumulate hard borrow-side rewards
|
|
multiRewardPeriod, found := suite.keeper.GetHardBorrowRewardPeriods(blockCtx, tc.args.borrow.Denom)
|
|
suite.Require().True(found)
|
|
err := suite.keeper.AccumulateHardBorrowRewards(blockCtx, multiRewardPeriod)
|
|
suite.Require().NoError(err)
|
|
}
|
|
updatedBlockTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * timeElapsed))
|
|
suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime)
|
|
|
|
// Confirm that the user's claim hasn't been synced
|
|
claimPre, foundPre := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3])
|
|
suite.Require().True(foundPre)
|
|
multiRewardIndexPre, _ := claimPre.BorrowRewardIndexes.GetRewardIndex(tc.args.borrow.Denom)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
currRewardIndex, found := multiRewardIndexPre.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(sdk.ZeroDec(), currRewardIndex.RewardFactor)
|
|
}
|
|
|
|
// Check that the synced claim held in memory has properly simulated syncing
|
|
syncedClaim := suite.keeper.SimulateHardSynchronization(suite.ctx, claim)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
// Check that the user's claim's reward index matches the expected reward index
|
|
multiRewardIndex, found := syncedClaim.BorrowRewardIndexes.GetRewardIndex(tc.args.borrow.Denom)
|
|
suite.Require().True(found)
|
|
rewardIndex, found := multiRewardIndex.RewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, rewardIndex)
|
|
|
|
// Check that the user's claim holds the expected amount of reward coins
|
|
suite.Require().Equal(
|
|
tc.args.expectedRewards.AmountOf(expectedRewardIndex.CollateralType),
|
|
syncedClaim.Reward.AmountOf(expectedRewardIndex.CollateralType),
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestSimulateHardDelegatorRewardSynchronization() {
|
|
type args struct {
|
|
delegation sdk.Coin
|
|
rewardsPerSecond sdk.Coins
|
|
initialTime time.Time
|
|
blockTimes []int
|
|
expectedRewardIndexes types.RewardIndexes
|
|
expectedRewards sdk.Coins
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
}
|
|
|
|
testCases := []test{
|
|
{
|
|
"10 blocks",
|
|
args{
|
|
delegation: c("ukava", 1_000_000),
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("ukava", d("6.117700000000000000"))}, // Here the reward index stores data differently than inside a MultiRewardIndex
|
|
expectedRewards: cs(c("hard", 6117700)),
|
|
},
|
|
},
|
|
{
|
|
"10 blocks - long block time",
|
|
args{
|
|
delegation: c("ukava", 1_000_000),
|
|
rewardsPerSecond: cs(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},
|
|
expectedRewardIndexes: types.RewardIndexes{types.NewRewardIndex("ukava", d("52856.928000000000000000"))},
|
|
expectedRewards: cs(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[0])},
|
|
types.MultiRewardPeriods{types.NewMultiRewardPeriod(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), 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[0])},
|
|
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)
|
|
|
|
// Accumulate hard delegator rewards
|
|
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)
|
|
|
|
// Check that the synced claim held in memory has properly simulated syncing
|
|
syncedClaim := suite.keeper.SimulateHardSynchronization(suite.ctx, claim)
|
|
for _, expectedRewardIndex := range tc.args.expectedRewardIndexes {
|
|
// Check that the user's claim's reward index matches the expected reward index
|
|
rewardIndex, found := syncedClaim.DelegatorRewardIndexes.GetRewardIndex(expectedRewardIndex.CollateralType)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedRewardIndex, rewardIndex)
|
|
|
|
// Check that the user's claim holds the expected amount of reward coins
|
|
suite.Require().Equal(
|
|
tc.args.expectedRewards.AmountOf(expectedRewardIndex.CollateralType),
|
|
syncedClaim.Reward.AmountOf(expectedRewardIndex.CollateralType),
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestSimulateUSDXMintingRewardSynchronization() {
|
|
type args struct {
|
|
ctype string
|
|
rewardsPerSecond sdk.Coins
|
|
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: cs(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: cs(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[0])},
|
|
types.MultiRewardPeriods{types.NewMultiRewardPeriod(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), 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[0])},
|
|
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.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) 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
|
|
}
|