0g-chain/x/incentive/keeper/payout_test.go

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)

}