package keeper_test import ( "fmt" "testing" "time" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/stretchr/testify/suite" abcitypes "github.com/tendermint/tendermint/abci/types" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" tmtime "github.com/tendermint/tendermint/types/time" "github.com/kava-labs/kava/app" "github.com/kava-labs/kava/x/community/keeper" "github.com/kava-labs/kava/x/community/testutil" "github.com/kava-labs/kava/x/community/types" hardkeeper "github.com/kava-labs/kava/x/hard/keeper" hardtypes "github.com/kava-labs/kava/x/hard/types" pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types" ) const chainID = "kavatest_2221-1" func ukava(amt int64) sdk.Coins { return sdk.NewCoins(sdk.NewInt64Coin("ukava", amt)) } func usdx(amt int64) sdk.Coins { return sdk.NewCoins(sdk.NewInt64Coin("usdx", amt)) } func otherdenom(amt int64) sdk.Coins { return sdk.NewCoins(sdk.NewInt64Coin("other-denom", amt)) } type proposalTestSuite struct { suite.Suite App app.TestApp Ctx sdk.Context Keeper keeper.Keeper MaccAddress sdk.AccAddress hardKeeper hardkeeper.Keeper } func TestProposalTestSuite(t *testing.T) { suite.Run(t, new(proposalTestSuite)) } func (suite *proposalTestSuite) SetupTest() { app.SetSDKConfig() genTime := tmtime.Now() hardGS, pricefeedGS := testutil.NewLendGenesisBuilder(). WithMarket("ukava", "kava:usd", sdk.OneDec()). WithMarket("usdx", "usdx:usd", sdk.OneDec()). Build() tApp := app.NewTestApp() ctx := tApp.NewContext(true, tmproto.Header{ Height: 1, Time: genTime, ChainID: chainID, }) tApp.InitializeFromGenesisStatesWithTimeAndChainID( genTime, chainID, app.GenesisState{hardtypes.ModuleName: tApp.AppCodec().MustMarshalJSON(&hardGS)}, app.GenesisState{pricefeedtypes.ModuleName: tApp.AppCodec().MustMarshalJSON(&pricefeedGS)}, ) suite.App = tApp suite.Ctx = ctx suite.Keeper = tApp.GetCommunityKeeper() suite.MaccAddress = tApp.GetAccountKeeper().GetModuleAddress(types.ModuleAccountName) suite.hardKeeper = suite.App.GetHardKeeper() // give the community pool some funds // ukava suite.FundCommunityPool(ukava(1e10)) // usdx suite.FundCommunityPool(usdx(1e10)) // other-denom suite.FundCommunityPool(otherdenom(1e10)) } func (suite *proposalTestSuite) NextBlock() { newTime := suite.Ctx.BlockTime().Add(6 * time.Second) newHeight := suite.Ctx.BlockHeight() + 1 suite.App.EndBlocker(suite.Ctx, abcitypes.RequestEndBlock{}) suite.Ctx = suite.Ctx.WithBlockTime(newTime).WithBlockHeight(newHeight).WithChainID(chainID) suite.App.BeginBlocker(suite.Ctx, abcitypes.RequestBeginBlock{}) } func (suite *proposalTestSuite) FundCommunityPool(coins sdk.Coins) { // mint to ephemeral account ephemeralAcc := app.RandomAddress() suite.NoError(suite.App.FundAccount(suite.Ctx, ephemeralAcc, coins)) // fund community pool with newly minted coins suite.NoError(suite.App.GetDistrKeeper().FundCommunityPool(suite.Ctx, coins, ephemeralAcc)) } func (suite *proposalTestSuite) GetCommunityPoolBalance() sdk.Coins { balance, change := suite.App.GetDistrKeeper().GetFeePoolCommunityCoins(suite.Ctx).TruncateDecimal() // expect no decimal dust suite.True(sdk.NewDecCoins().IsEqual(change), "expected no decimal dust in community pool") return balance } func (suite *proposalTestSuite) CheckCommunityPoolBalance(expected sdk.Coins) { actual := suite.GetCommunityPoolBalance() // check that balance is expected suite.True(expected.IsEqual(actual), fmt.Sprintf("unexpected balance in community pool\nexpected: %s\nactual: %s", expected, actual)) } func (suite *proposalTestSuite) TestCommunityLendDepositProposal() { testCases := []struct { name string proposals []*types.CommunityPoolLendDepositProposal expectedErr string expectedDeposits []sdk.Coins }{ { name: "valid - one proposal, one denom", proposals: []*types.CommunityPoolLendDepositProposal{ {Amount: ukava(1e8)}, }, expectedErr: "", expectedDeposits: []sdk.Coins{ukava(1e8)}, }, { name: "valid - one proposal, multiple denoms", proposals: []*types.CommunityPoolLendDepositProposal{ {Amount: ukava(1e8).Add(usdx(1e8)...)}, }, expectedErr: "", expectedDeposits: []sdk.Coins{ukava(1e8).Add(usdx(1e8)...)}, }, { name: "valid - multiple proposals, same denom", proposals: []*types.CommunityPoolLendDepositProposal{ {Amount: ukava(1e8)}, {Amount: ukava(1e9)}, }, expectedErr: "", expectedDeposits: []sdk.Coins{ukava(1e8 + 1e9)}, }, { name: "valid - multiple proposals, different denoms", proposals: []*types.CommunityPoolLendDepositProposal{ {Amount: ukava(1e8)}, {Amount: usdx(1e8)}, }, expectedErr: "", expectedDeposits: []sdk.Coins{ukava(1e8).Add(usdx(1e8)...)}, }, { name: "invalid - insufficient balance", proposals: []*types.CommunityPoolLendDepositProposal{ { Description: "more coins than i have!", Amount: ukava(1e11), }, }, expectedErr: "community pool does not have sufficient coins to distribute", expectedDeposits: []sdk.Coins{}, }, { name: "invalid - invalid lend deposit (unsupported denom)", proposals: []*types.CommunityPoolLendDepositProposal{ {Amount: otherdenom(1e9)}, }, expectedErr: "invalid deposit denom", expectedDeposits: []sdk.Coins{}, }, } for _, tc := range testCases { suite.Run(tc.name, func() { suite.SetupTest() for _, proposal := range tc.proposals { err := keeper.HandleCommunityPoolLendDepositProposal(suite.Ctx, suite.Keeper, proposal) if tc.expectedErr == "" { suite.NoError(err) } else { suite.ErrorContains(err, tc.expectedErr) } } deposits := suite.hardKeeper.GetDepositsByUser(suite.Ctx, suite.MaccAddress) suite.Len(deposits, len(tc.expectedDeposits), "expected a deposit to lend") for _, amt := range tc.expectedDeposits { suite.Equal(amt, deposits[0].Amount, "expected amount to match") } }) } } func (suite *proposalTestSuite) TestCommunityLendWithdrawProposal() { testCases := []struct { name string initialDeposit sdk.Coins proposals []*types.CommunityPoolLendWithdrawProposal expectedErr string expectedWithdrawal sdk.Coins }{ { // in the week it would take a proposal to pass, the position would have grown // to withdraw the entire position, it'd be safest to set a very high withdraw name: "valid - requesting withdrawal of more than total will withdraw all", initialDeposit: ukava(1e9), proposals: []*types.CommunityPoolLendWithdrawProposal{ {Amount: ukava(1e12)}, }, expectedErr: "", expectedWithdrawal: ukava(1e9), }, { name: "valid - single proposal, single denom, full withdrawal", initialDeposit: ukava(1e9), proposals: []*types.CommunityPoolLendWithdrawProposal{ {Amount: ukava(1e9)}, }, expectedErr: "", expectedWithdrawal: ukava(1e9), }, { name: "valid - single proposal, multiple denoms, full withdrawal", initialDeposit: ukava(1e9).Add(usdx(1e9)...), proposals: []*types.CommunityPoolLendWithdrawProposal{ {Amount: ukava(1e9).Add(usdx(1e9)...)}, }, expectedErr: "", expectedWithdrawal: ukava(1e9).Add(usdx(1e9)...), }, { name: "valid - single proposal, partial withdrawal", initialDeposit: ukava(1e9).Add(usdx(1e9)...), proposals: []*types.CommunityPoolLendWithdrawProposal{ {Amount: ukava(1e8).Add(usdx(1e9)...)}, }, expectedErr: "", expectedWithdrawal: ukava(1e8).Add(usdx(1e9)...), }, { name: "valid - multiple proposals, full withdrawal", initialDeposit: ukava(1e9).Add(usdx(1e9)...), proposals: []*types.CommunityPoolLendWithdrawProposal{ {Amount: ukava(1e9)}, {Amount: usdx(1e9)}, }, expectedErr: "", expectedWithdrawal: ukava(1e9).Add(usdx(1e9)...), }, { name: "valid - multiple proposals, partial withdrawal", initialDeposit: ukava(1e9).Add(usdx(1e9)...), proposals: []*types.CommunityPoolLendWithdrawProposal{ {Amount: ukava(1e8)}, {Amount: usdx(1e8)}, }, expectedErr: "", expectedWithdrawal: ukava(1e8).Add(usdx(1e8)...), }, { name: "invalid - nonexistent position, has no deposits", initialDeposit: sdk.NewCoins(), proposals: []*types.CommunityPoolLendWithdrawProposal{ {Amount: ukava(1e8)}, }, expectedErr: "deposit not found", expectedWithdrawal: sdk.NewCoins(), }, { name: "invalid - nonexistent position, has deposits of different denom", initialDeposit: ukava(1e8), proposals: []*types.CommunityPoolLendWithdrawProposal{ {Amount: usdx(1e8)}, }, expectedErr: "no coins of this type deposited", expectedWithdrawal: sdk.NewCoins(), }, } for _, tc := range testCases { suite.Run(tc.name, func() { suite.SetupTest() // Disable minting, so that the community pool balance doesn't change // during the test - this is because staking denom is "ukava" and no // longer "stake" which has an initial and changing balance instead // of just 0 suite.App.SetInflation(suite.Ctx, sdk.ZeroDec()) // setup initial deposit if !tc.initialDeposit.IsZero() { deposit := types.NewCommunityPoolLendDepositProposal("initial deposit", "has coins", tc.initialDeposit) err := keeper.HandleCommunityPoolLendDepositProposal(suite.Ctx, suite.Keeper, deposit) suite.NoError(err, "unexpected error while seeding lend deposit") } beforeBalance := suite.GetCommunityPoolBalance() // run the proposals for i, proposal := range tc.proposals { fmt.Println("submitting proposal ", i, " ", suite.Ctx.ChainID()) err := keeper.HandleCommunityPoolLendWithdrawProposal(suite.Ctx, suite.Keeper, proposal) if tc.expectedErr == "" { suite.NoError(err) } else { suite.ErrorContains(err, tc.expectedErr) } suite.NextBlock() } // expect funds to be removed from hard deposit expectedRemaining := tc.initialDeposit.Sub(tc.expectedWithdrawal...) deposits := suite.hardKeeper.GetDepositsByUser(suite.Ctx, suite.MaccAddress) if expectedRemaining.IsZero() { suite.Len(deposits, 0, "expected all deposits to be withdrawn") } else { suite.Len(deposits, 1, "expected user to have remaining deposit") suite.Equal(expectedRemaining, deposits[0].Amount) } // expect funds to be distributed back to community pool suite.CheckCommunityPoolBalance(beforeBalance.Add(tc.expectedWithdrawal...)) }) } }