smeb_y/0g-chain
1
0
Fork 0
mirror of https://github.com/0glabs/0g-chain.git synced 2024-12-27 16:55:21 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
b539820c88
0g-chain/x/incentive/keeper/payout_test.go
Federico Kunze fe72a24aa0
update format
2020-04-30 10:23:41 -04:00

360 lines
14 KiB
Go
Raw Blame History

package keeper_test
import (
"errors"
"time"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/cosmos/cosmos-sdk/x/auth/vesting"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/kava-labs/kava/app"
"github.com/kava-labs/kava/x/cdp"
"github.com/kava-labs/kava/x/incentive/types"
"github.com/kava-labs/kava/x/kavadist"
validatorvesting "github.com/kava-labs/kava/x/validator-vesting"
)
func (suite *KeeperTestSuite) setupChain() {
// creates a new app state with 4 funded addresses and 1 module account
tApp := app.NewTestApp()
ctx := tApp.NewContext(true, abci.Header{Height: 1, Time: time.Unix(100, 0)})
_, addrs := app.GeneratePrivKeyAddressPairs(4)
authGS := app.NewAuthGenState(
addrs,
[]sdk.Coins{
cs(c("ukava", 400)),
cs(c("ukava", 400)),
cs(c("ukava", 400)),
cs(c("ukava", 400)),
})
tApp.InitializeFromGenesisStates(
authGS,
)
supplyKeeper := tApp.GetSupplyKeeper()
macc := supplyKeeper.GetModuleAccount(ctx, kavadist.ModuleName)
err := supplyKeeper.MintCoins(ctx, macc.GetName(), cs(c("ukava", 500)))
suite.Require().NoError(err)
// sets addrs[0] to be a periodic vesting account
ak := tApp.GetAccountKeeper()
acc := ak.GetAccount(ctx, addrs[0])
bacc := auth.NewBaseAccount(acc.GetAddress(), acc.GetCoins(), acc.GetPubKey(), acc.GetAccountNumber(), acc.GetSequence())
periods := vesting.Periods{
vesting.Period{Length: int64(1), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(2), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(8), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(5), Amount: cs(c("ukava", 100))},
}
bva, err2 := vesting.NewBaseVestingAccount(bacc, cs(c("ukava", 400)), ctx.BlockTime().Unix()+16)
suite.Require().NoError(err2)
pva := vesting.NewPeriodicVestingAccountRaw(bva, ctx.BlockTime().Unix(), periods)
ak.SetAccount(ctx, pva)
// sets addrs[2] to be a validator vesting account
acc = ak.GetAccount(ctx, addrs[2])
bacc = auth.NewBaseAccount(acc.GetAddress(), acc.GetCoins(), acc.GetPubKey(), acc.GetAccountNumber(), acc.GetSequence())
bva, err2 = vesting.NewBaseVestingAccount(bacc, cs(c("ukava", 400)), ctx.BlockTime().Unix()+16)
suite.Require().NoError(err2)
vva := validatorvesting.NewValidatorVestingAccountRaw(bva, ctx.BlockTime().Unix(), periods, sdk.ConsAddress{}, nil, 90)
ak.SetAccount(ctx, vva)
suite.app = tApp
suite.keeper = tApp.GetIncentiveKeeper()
suite.ctx = ctx
suite.addrs = addrs
}
func (suite *KeeperTestSuite) setupExpiredClaims() {
// creates a new app state with 4 funded addresses
tApp := app.NewTestApp()
ctx := tApp.NewContext(true, abci.Header{Height: 1, Time: time.Unix(100, 0)})
_, addrs := app.GeneratePrivKeyAddressPairs(4)
authGS := app.NewAuthGenState(
addrs,
[]sdk.Coins{
cs(c("ukava", 400)),
cs(c("ukava", 400)),
cs(c("ukava", 400)),
cs(c("ukava", 400)),
})
tApp.InitializeFromGenesisStates(
authGS,
)
// creates two claim periods, one expired, and one that expires in the future
cp1 := types.NewClaimPeriod("bnb", 1, time.Unix(90, 0), time.Hour*8766)
cp2 := types.NewClaimPeriod("xrp", 1, time.Unix(110, 0), time.Hour*8766)
suite.keeper = tApp.GetIncentiveKeeper()
suite.keeper.SetClaimPeriod(ctx, cp1)
suite.keeper.SetClaimPeriod(ctx, cp2)
// creates one claim for the non-expired claim period and one claim for the expired claim period
c1 := types.NewClaim(addrs[0], c("ukava", 1000000), "bnb", 1)
c2 := types.NewClaim(addrs[0], c("ukava", 1000000), "xrp", 1)
suite.keeper.SetClaim(ctx, c1)
suite.keeper.SetClaim(ctx, c2)
suite.app = tApp
suite.ctx = ctx
suite.addrs = addrs
}
func (suite *KeeperTestSuite) TestSendCoinsToPeriodicVestingAccount() {
suite.setupChain()
type args struct {
coins sdk.Coins
length int64
}
type errArgs struct {
expectErr bool
errType error
}
type vestingAccountTest struct {
name string
blockTime time.Time
args args
errArgs errArgs
expectedPeriods vesting.Periods
expectedOriginalVesting sdk.Coins
expectedCoins sdk.Coins
expectedStartTime int64
expectedEndTime int64
}
type vestingAccountTests []vestingAccountTest
testCases := vestingAccountTests{
vestingAccountTest{
name: "insert period into an existing vesting schedule",
blockTime: time.Unix(100, 0),
args: args{coins: cs(c("ukava", 100)), length: 5},
errArgs: errArgs{expectErr: false, errType: nil},
expectedPeriods: vesting.Periods{
vesting.Period{Length: int64(1), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(2), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(2), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(6), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(5), Amount: cs(c("ukava", 100))},
},
expectedOriginalVesting: cs(c("ukava", 500)),
expectedCoins: cs(c("ukava", 500)),
expectedStartTime: int64(100),
expectedEndTime: int64(116),
},
vestingAccountTest{
name: "append period to the end of an existing vesting schedule",
blockTime: time.Unix(100, 0),
args: args{coins: cs(c("ukava", 100)), length: 17},
errArgs: errArgs{expectErr: false, errType: nil},
expectedPeriods: vesting.Periods{
vesting.Period{Length: int64(1), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(2), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(2), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(6), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(5), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(1), Amount: cs(c("ukava", 100))},
},
expectedOriginalVesting: cs(c("ukava", 600)),
expectedCoins: cs(c("ukava", 600)),
expectedStartTime: int64(100),
expectedEndTime: int64(117),
},
vestingAccountTest{
name: "append period to the end of a completed vesting schedule",
blockTime: time.Unix(120, 0),
args: args{coins: cs(c("ukava", 100)), length: 5},
errArgs: errArgs{expectErr: false, errType: nil},
expectedPeriods: vesting.Periods{
vesting.Period{Length: int64(1), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(2), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(2), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(6), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(5), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(1), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(8), Amount: cs(c("ukava", 100))},
},
expectedOriginalVesting: cs(c("ukava", 700)),
expectedCoins: cs(c("ukava", 700)),
expectedStartTime: int64(100),
expectedEndTime: int64(125),
},
vestingAccountTest{
name: "prepend period to to an upcoming vesting schedule",
blockTime: time.Unix(90, 0),
args: args{coins: cs(c("ukava", 100)), length: 5},
errArgs: errArgs{expectErr: false, errType: nil},
expectedPeriods: vesting.Periods{
vesting.Period{Length: int64(5), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(6), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(2), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(2), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(6), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(5), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(1), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(8), Amount: cs(c("ukava", 100))},
},
expectedOriginalVesting: cs(c("ukava", 800)),
expectedCoins: cs(c("ukava", 800)),
expectedStartTime: int64(90),
expectedEndTime: int64(125),
},
vestingAccountTest{
name: "add period that coincides with an existing end time",
blockTime: time.Unix(90, 0),
args: args{coins: cs(c("ukava", 100)), length: 11},
errArgs: errArgs{expectErr: false, errType: nil},
expectedPeriods: vesting.Periods{
vesting.Period{Length: int64(5), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(6), Amount: cs(c("ukava", 200))},
vesting.Period{Length: int64(2), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(2), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(6), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(5), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(1), Amount: cs(c("ukava", 100))},
vesting.Period{Length: int64(8), Amount: cs(c("ukava", 100))},
},
expectedOriginalVesting: cs(c("ukava", 900)),
expectedCoins: cs(c("ukava", 900)),
expectedStartTime: int64(90),
expectedEndTime: int64(125),
},
vestingAccountTest{
name: "insufficient module account balance",
blockTime: time.Unix(90, 0),
args: args{coins: cs(c("ukava", 1000)), length: 11},
errArgs: errArgs{expectErr: true, errType: types.ErrInsufficientModAccountBalance},
expectedPeriods: vesting.Periods{},
expectedOriginalVesting: sdk.Coins{},
expectedCoins: sdk.Coins{},
expectedStartTime: int64(0),
expectedEndTime: int64(0),
},
}
for _, tc := range testCases {
suite.Run(tc.name, func() {
suite.ctx = suite.ctx.WithBlockTime(tc.blockTime)
err := suite.keeper.SendTimeLockedCoinsToAccount(suite.ctx, kavadist.ModuleName, suite.addrs[0], tc.args.coins, tc.args.length)
if tc.errArgs.expectErr {
suite.Require().True(errors.Is(err, tc.errArgs.errType))
} else {
suite.Require().NoError(err)
acc := suite.getAccount(suite.addrs[0])
vacc, ok := acc.(*vesting.PeriodicVestingAccount)
suite.True(ok)
suite.Equal(tc.expectedPeriods, vacc.VestingPeriods)
suite.Equal(tc.expectedOriginalVesting, vacc.OriginalVesting)
suite.Equal(tc.expectedCoins, vacc.Coins)
suite.Equal(tc.expectedStartTime, vacc.StartTime)
suite.Equal(tc.expectedEndTime, vacc.EndTime)
}
})
}
}
func (suite *KeeperTestSuite) TestSendCoinsToBaseAccount() {
suite.setupChain()
// send coins to base account
err := suite.keeper.SendTimeLockedCoinsToAccount(suite.ctx, kavadist.ModuleName, suite.addrs[1], cs(c("ukava", 100)), 5)
suite.Require().NoError(err)
acc := suite.getAccount(suite.addrs[1])
vacc, ok := acc.(*vesting.PeriodicVestingAccount)
suite.True(ok)
expectedPeriods := vesting.Periods{
vesting.Period{Length: int64(5), Amount: cs(c("ukava", 100))},
}
suite.Equal(expectedPeriods, vacc.VestingPeriods)
suite.Equal(cs(c("ukava", 100)), vacc.OriginalVesting)
suite.Equal(cs(c("ukava", 500)), vacc.Coins)
suite.Equal(int64(105), vacc.EndTime)
suite.Equal(int64(100), vacc.StartTime)
}
func (suite *KeeperTestSuite) TestSendCoinsToInvalidAccount() {
suite.setupChain()
err := suite.keeper.SendTimeLockedCoinsToAccount(suite.ctx, kavadist.ModuleName, suite.addrs[2], cs(c("ukava", 100)), 5)
suite.Require().True(errors.Is(err, types.ErrInvalidAccountType))
macc := suite.getModuleAccount(cdp.ModuleName)
err = suite.keeper.SendTimeLockedCoinsToAccount(suite.ctx, kavadist.ModuleName, macc.GetAddress(), cs(c("ukava", 100)), 5)
suite.Require().True(errors.Is(err, types.ErrInvalidAccountType))
}
func (suite *KeeperTestSuite) TestPayoutClaim() {
suite.setupChain() // adds 3 accounts - 1 periodic vesting account, 1 base account, and 1 validator vesting account
// add 2 claims that correspond to an existing claim period and one claim that has no corresponding claim period
cp1 := types.NewClaimPeriod("bnb", 1, suite.ctx.BlockTime().Add(time.Hour*168), time.Hour*8766)
suite.keeper.SetClaimPeriod(suite.ctx, cp1)
// valid claim for addrs[0]
c1 := types.NewClaim(suite.addrs[0], c("ukava", 100), "bnb", 1)
// invalid claim for addrs[0]
c2 := types.NewClaim(suite.addrs[0], c("ukava", 100), "xrp", 1)
// valid claim for addrs[1]
c3 := types.NewClaim(suite.addrs[1], c("ukava", 100), "bnb", 1)
suite.keeper.SetClaim(suite.ctx, c1)
suite.keeper.SetClaim(suite.ctx, c2)
suite.keeper.SetClaim(suite.ctx, c3)
// existing claim with corresponding claim period successfully claimed by existing periodic vesting account
err := suite.keeper.PayoutClaim(suite.ctx, suite.addrs[0], "bnb", 1)
suite.Require().NoError(err)
acc := suite.getAccount(suite.addrs[0])
// account is a periodic vesting account
vacc, ok := acc.(*vesting.PeriodicVestingAccount)
suite.True(ok)
// vesting balance is correct
suite.Equal(cs(c("ukava", 500)), vacc.OriginalVesting)
// existing claim with corresponding claim period successfully claimed by base account
err = suite.keeper.PayoutClaim(suite.ctx, suite.addrs[1], "bnb", 1)
suite.Require().NoError(err)
acc = suite.getAccount(suite.addrs[1])
// account has become a periodic vesting account
vacc, ok = acc.(*vesting.PeriodicVestingAccount)
suite.True(ok)
// vesting balance is correct
suite.Equal(cs(c("ukava", 100)), vacc.OriginalVesting)
// addrs[3] has no claims
err = suite.keeper.PayoutClaim(suite.ctx, suite.addrs[3], "bnb", 1)
suite.Require().True(errors.Is(err, types.ErrClaimNotFound))
// addrs[0] has an xrp claim, but there is not corresponding claim period
err = suite.keeper.PayoutClaim(suite.ctx, suite.addrs[0], "xrp", 1)
suite.Require().True(errors.Is(err, types.ErrClaimPeriodNotFound))
}
func (suite *KeeperTestSuite) TestDeleteExpiredClaimPeriods() {
suite.setupExpiredClaims() // creates new app state with one non-expired claim period (xrp) and one expired claim period (bnb) as well as a claim that corresponds to each claim period
// both claim periods are present
_, found := suite.keeper.GetClaimPeriod(suite.ctx, 1, "bnb")
suite.True(found)
_, found = suite.keeper.GetClaimPeriod(suite.ctx, 1, "xrp")
suite.True(found)
// both claims are present
_, found = suite.keeper.GetClaim(suite.ctx, suite.addrs[0], "bnb", 1)
suite.True(found)
_, found = suite.keeper.GetClaim(suite.ctx, suite.addrs[0], "xrp", 1)
suite.True(found)
// expired claim period and associated claims should get deleted
suite.NotPanics(func() {
suite.keeper.DeleteExpiredClaimsAndClaimPeriods(suite.ctx)
})
// expired claim period and claim are not found
_, found = suite.keeper.GetClaimPeriod(suite.ctx, 1, "bnb")
suite.False(found)
_, found = suite.keeper.GetClaim(suite.ctx, suite.addrs[0], "bnb", 1)
suite.False(found)
// non-expired claim period and claim are found
_, found = suite.keeper.GetClaimPeriod(suite.ctx, 1, "xrp")
suite.True(found)
_, found = suite.keeper.GetClaim(suite.ctx, suite.addrs[0], "xrp", 1)
suite.True(found)
}
Reference in New Issue View Git Blame Copy Permalink