diff --git a/CHANGELOG.md b/CHANGELOG.md index 1a32735bd12..541a0c79128 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -86,6 +86,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 * [1698](https://github.com/osmosis-labs/osmosis/pull/1698) Register wasm snapshotter extension. * [1931](https://github.com/osmosis-labs/osmosis/pull/1931) Add explicit check for input denoms to `CalcJoinPoolShares` * [2011](https://github.com/osmosis-labs/osmosis/pull/2011) Fix bug in TokenFactory initGenesis, relating to denom creation fee param. +* [2186](https://github.com/osmosis-labs/osmosis/pull/2186) Remove liquidity event that was emitted twice per message. ### Improvements * [#2214](https://github.com/osmosis-labs/osmosis/pull/2214) Speedup epoch distribution, superfluid component diff --git a/app/apptesting/events.go b/app/apptesting/events.go new file mode 100644 index 00000000000..f5a434937de --- /dev/null +++ b/app/apptesting/events.go @@ -0,0 +1,17 @@ +package apptesting + +import sdk "github.com/cosmos/cosmos-sdk/types" + +// AssertEventEmitted asserts that ctx's event manager has emitted the given number of events +// of the given type. +func (s *KeeperTestHelper) AssertEventEmitted(ctx sdk.Context, eventTypeExpected string, numEventsExpected int) { + allEvents := ctx.EventManager().Events() + // filter out other events + actualEvents := make([]sdk.Event, 0) + for _, event := range allEvents { + if event.Type == eventTypeExpected { + actualEvents = append(actualEvents, event) + } + } + s.Equal(numEventsExpected, len(actualEvents)) +} diff --git a/x/gamm/README.md b/x/gamm/README.md index 1cccc21f134..bf00cf9da35 100644 --- a/x/gamm/README.md +++ b/x/gamm/README.md @@ -583,6 +583,17 @@ It consists of the following attributes: This event is emitted after `ExitPool` completes exiting the requested pool successfully. +It consists of the following attributes: + +* `sdk.AttributeKeyModule` - "module" + * The value is the module's name - "gamm". +* `sdk.AttributeKeySender` + * The value is the address of the sender who created the swap message. +* `types.AttributeKeyPoolId` + * The value is the pool id of the pool where swap occurs. +* `types.AttributeKeyTokensOut` + * The value is the string representation of the tokens being swapped out. + ### `types.TypeEvtPoolCreated` This event is emitted after `CreatePool` completes creating diff --git a/x/gamm/keeper/internal/events/emit_test.go b/x/gamm/keeper/internal/events/emit_test.go index 6f17918a976..976da14ef13 100644 --- a/x/gamm/keeper/internal/events/emit_test.go +++ b/x/gamm/keeper/internal/events/emit_test.go @@ -139,3 +139,57 @@ func (suite *GammEventsTestSuite) TestEmitAddLiquidityEvent() { }) } } + +func (suite *GammEventsTestSuite) TestEmitRemoveLiquidityEvent() { + testcases := map[string]struct { + ctx sdk.Context + testAccountAddr sdk.AccAddress + poolId uint64 + tokensOut sdk.Coins + }{ + "basic valid": { + ctx: suite.CreateTestContext(), + testAccountAddr: sdk.AccAddress([]byte(addressString)), + poolId: 1, + tokensOut: sdk.NewCoins(sdk.NewCoin(testDenomA, sdk.NewInt(1234))), + }, + "context with no event manager": { + ctx: sdk.Context{}, + }, + "valid with multiple tokens out": { + ctx: suite.CreateTestContext(), + testAccountAddr: sdk.AccAddress([]byte(addressString)), + poolId: 200, + tokensOut: sdk.NewCoins(sdk.NewCoin(testDenomA, sdk.NewInt(12)), sdk.NewCoin(testDenomB, sdk.NewInt(99))), + }, + } + + for name, tc := range testcases { + suite.Run(name, func() { + expectedEvents := sdk.Events{ + sdk.NewEvent( + types.TypeEvtPoolExited, + sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory), + sdk.NewAttribute(sdk.AttributeKeySender, tc.testAccountAddr.String()), + sdk.NewAttribute(types.AttributeKeyPoolId, strconv.FormatUint(tc.poolId, 10)), + sdk.NewAttribute(types.AttributeKeyTokensOut, tc.tokensOut.String()), + ), + } + + hasNoEventManager := tc.ctx.EventManager() == nil + + // System under test. + events.EmitRemoveLiquidityEvent(tc.ctx, tc.testAccountAddr, tc.poolId, tc.tokensOut) + + // Assertions + if hasNoEventManager { + // If there is no event manager on context, this is a no-op. + return + } + + eventManager := tc.ctx.EventManager() + actualEvents := eventManager.Events() + suite.Equal(expectedEvents, actualEvents) + }) + } +} diff --git a/x/gamm/keeper/msg_server.go b/x/gamm/keeper/msg_server.go index e58ba23334d..a41d81456b6 100644 --- a/x/gamm/keeper/msg_server.go +++ b/x/gamm/keeper/msg_server.go @@ -145,10 +145,6 @@ func (server msgServer) ExitPool(goCtx context.Context, msg *types.MsgExitPool) } ctx.EventManager().EmitEvents(sdk.Events{ - sdk.NewEvent( - types.TypeEvtPoolExited, - sdk.NewAttribute(types.AttributeKeyPoolId, strconv.FormatUint(msg.PoolId, 10)), - ), sdk.NewEvent( sdk.EventTypeMessage, sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory), diff --git a/x/gamm/keeper/msg_server_test.go b/x/gamm/keeper/msg_server_test.go index 1920adc8fd8..6c689eda537 100644 --- a/x/gamm/keeper/msg_server_test.go +++ b/x/gamm/keeper/msg_server_test.go @@ -12,6 +12,8 @@ import ( const ( doesNotExistDenom = "nodenom" + // Max positive int64. + int64Max = int64(^uint64(0) >> 1) ) func TestMsgServerTestSuite(t *testing.T) { @@ -50,7 +52,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountIn_Events() { tokenIn: sdk.NewCoin("foo", sdk.NewInt(tokenIn)), tokenOutMinAmount: sdk.NewInt(tokenInMinAmount), expectedSwapEvents: 1, - expectedMessageEvents: 3, // 1 gamm + 2 tendermint. + expectedMessageEvents: 3, // 1 gamm + 2 events emitted by other keeper methods. }, "two hops": { routes: []types.SwapAmountInRoute{ @@ -66,7 +68,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountIn_Events() { tokenIn: sdk.NewCoin("foo", sdk.NewInt(tokenIn)), tokenOutMinAmount: sdk.NewInt(tokenInMinAmount), expectedSwapEvents: 2, - expectedMessageEvents: 5, // 1 gamm + 4 tendermint. + expectedMessageEvents: 5, // 1 gamm + 4 events emitted by other keeper methods. }, "invalid - two hops, denom does not exist": { routes: []types.SwapAmountInRoute{ @@ -111,8 +113,8 @@ func (suite *KeeperTestSuite) TestSwapExactAmountIn_Events() { suite.NotNil(response) } - assertEventEmitted(suite, ctx, types.TypeEvtTokenSwapped, tc.expectedSwapEvents) - assertEventEmitted(suite, ctx, sdk.EventTypeMessage, tc.expectedMessageEvents) + suite.AssertEventEmitted(ctx, types.TypeEvtTokenSwapped, tc.expectedSwapEvents) + suite.AssertEventEmitted(ctx, sdk.EventTypeMessage, tc.expectedMessageEvents) }) } } @@ -121,8 +123,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountIn_Events() { // when calling SwapExactAmountOut. func (suite *KeeperTestSuite) TestSwapExactAmountOut_Events() { const ( - // Max positive int64. - tokenInMaxAmount = int64(^uint64(0) >> 1) + tokenInMaxAmount = int64Max tokenOut = 5 ) @@ -150,7 +151,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountOut_Events() { tokenOut: sdk.NewCoin("foo", sdk.NewInt(tokenOut)), tokenInMaxAmount: sdk.NewInt(tokenInMaxAmount), expectedSwapEvents: 1, - expectedMessageEvents: 3, // 1 gamm + 2 tendermint. + expectedMessageEvents: 3, // 1 gamm + 2 events emitted by other keeper methods. }, "two hops": { routes: []types.SwapAmountOutRoute{ @@ -166,7 +167,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountOut_Events() { tokenOut: sdk.NewCoin("foo", sdk.NewInt(tokenOut)), tokenInMaxAmount: sdk.NewInt(tokenInMaxAmount), expectedSwapEvents: 2, - expectedMessageEvents: 5, // 1 gamm + 4 tendermint. + expectedMessageEvents: 5, // 1 gamm + 4 events emitted by other keeper methods. }, "invalid - two hops, denom does not exist": { routes: []types.SwapAmountOutRoute{ @@ -211,8 +212,8 @@ func (suite *KeeperTestSuite) TestSwapExactAmountOut_Events() { suite.NotNil(response) } - assertEventEmitted(suite, ctx, types.TypeEvtTokenSwapped, tc.expectedSwapEvents) - assertEventEmitted(suite, ctx, sdk.EventTypeMessage, tc.expectedMessageEvents) + suite.AssertEventEmitted(ctx, types.TypeEvtTokenSwapped, tc.expectedSwapEvents) + suite.AssertEventEmitted(ctx, sdk.EventTypeMessage, tc.expectedMessageEvents) }) } } @@ -221,8 +222,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountOut_Events() { // when calling JoinPool. func (suite *KeeperTestSuite) TestJoinPool_Events() { const ( - // Max positive int64. - tokenInMaxAmount = int64(^uint64(0) >> 1) + tokenInMaxAmount = int64Max shareOut = 110 ) @@ -243,7 +243,7 @@ func (suite *KeeperTestSuite) TestJoinPool_Events() { sdk.NewCoin("baz", sdk.NewInt(tokenInMaxAmount)), ), expectedAddLiquidityEvents: 1, - expectedMessageEvents: 3, // 1 gamm + 2 tendermint. + expectedMessageEvents: 3, // 1 gamm + 2 events emitted by other keeper methods. }, "tokenInMaxs do not match all tokens in pool - invalid join": { poolId: 1, @@ -258,7 +258,6 @@ func (suite *KeeperTestSuite) TestJoinPool_Events() { suite.Setup() ctx := suite.Ctx - suite.PrepareBalancerPool() suite.PrepareBalancerPool() msgServer := keeper.NewMsgServerImpl(suite.App.GAMMKeeper) @@ -279,20 +278,85 @@ func (suite *KeeperTestSuite) TestJoinPool_Events() { suite.Require().NotNil(response) } - assertEventEmitted(suite, ctx, types.TypeEvtPoolJoined, tc.expectedAddLiquidityEvents) - assertEventEmitted(suite, ctx, sdk.EventTypeMessage, tc.expectedMessageEvents) + suite.AssertEventEmitted(ctx, types.TypeEvtPoolJoined, tc.expectedAddLiquidityEvents) + suite.AssertEventEmitted(ctx, sdk.EventTypeMessage, tc.expectedMessageEvents) }) } } -func assertEventEmitted(suite *KeeperTestSuite, ctx sdk.Context, eventTypeExpected string, numEventsExpected int) { - allEvents := ctx.EventManager().Events() - // filter out other events - actualEvents := make([]sdk.Event, 0, 1) - for _, event := range allEvents { - if event.Type == eventTypeExpected { - actualEvents = append(actualEvents, event) - } +// TestExitPool_Events tests that events are correctly emitted +// when calling ExitPool. +func (suite *KeeperTestSuite) TestExitPool_Events() { + const ( + tokenOutMinAmount = 1 + shareIn = 110 + ) + + testcases := map[string]struct { + poolId uint64 + shareInAmount sdk.Int + tokenOutMins sdk.Coins + expectError bool + expectedRemoveLiquidityEvents int + expectedMessageEvents int + }{ + "successful exit": { + poolId: 1, + shareInAmount: sdk.NewInt(shareIn), + tokenOutMins: sdk.NewCoins(), + expectedRemoveLiquidityEvents: 1, + expectedMessageEvents: 3, // 1 gamm + 2 events emitted by other keeper methods. + }, + "invalid tokenOutMins": { + poolId: 1, + shareInAmount: sdk.NewInt(shareIn), + tokenOutMins: sdk.NewCoins(sdk.NewCoin("foo", sdk.NewInt(tokenOutMinAmount))), + expectError: true, + }, + } + + for name, tc := range testcases { + suite.Run(name, func() { + suite.Setup() + ctx := suite.Ctx + + suite.PrepareBalancerPool() + msgServer := keeper.NewMsgServerImpl(suite.App.GAMMKeeper) + + sender := suite.TestAccs[0].String() + + // Pre-join pool to be able to ExitPool. + joinPoolResponse, err := msgServer.JoinPool(sdk.WrapSDKContext(ctx), &types.MsgJoinPool{ + Sender: sender, + PoolId: tc.poolId, + ShareOutAmount: sdk.NewInt(shareIn), + TokenInMaxs: sdk.NewCoins( + sdk.NewCoin("foo", sdk.NewInt(int64Max)), + sdk.NewCoin("bar", sdk.NewInt(int64Max)), + sdk.NewCoin("baz", sdk.NewInt(int64Max)), + ), + }) + suite.Require().NoError(err) + + // Reset event counts to 0 by creating a new manager. + ctx = ctx.WithEventManager(sdk.NewEventManager()) + suite.Require().Equal(0, len(ctx.EventManager().Events())) + + // System under test. + response, err := msgServer.ExitPool(sdk.WrapSDKContext(ctx), &types.MsgExitPool{ + Sender: sender, + PoolId: tc.poolId, + ShareInAmount: joinPoolResponse.ShareOutAmount, + TokenOutMins: tc.tokenOutMins, + }) + + if !tc.expectError { + suite.Require().NoError(err) + suite.Require().NotNil(response) + } + + suite.AssertEventEmitted(ctx, types.TypeEvtPoolExited, tc.expectedRemoveLiquidityEvents) + suite.AssertEventEmitted(ctx, sdk.EventTypeMessage, tc.expectedMessageEvents) + }) } - suite.Require().Equal(numEventsExpected, len(actualEvents)) } diff --git a/x/gamm/keeper/pool_service_test.go b/x/gamm/keeper/pool_service_test.go index 36f7457fb56..21c48f3344b 100644 --- a/x/gamm/keeper/pool_service_test.go +++ b/x/gamm/keeper/pool_service_test.go @@ -40,6 +40,7 @@ var ( func (suite *KeeperTestSuite) TestCreateBalancerPool() { params := suite.App.GAMMKeeper.GetParams(suite.Ctx) + testAccount := suite.TestAccs[0] // get raw pool creation fee(s) as DecCoins poolCreationFeeDecCoins := sdk.DecCoins{} @@ -56,17 +57,17 @@ func (suite *KeeperTestSuite) TestCreateBalancerPool() { }{ { name: "create pool with default assets", - msg: balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], defaultPoolParams, defaultPoolAssets, defaultFutureGovernor), + msg: balancer.NewMsgCreateBalancerPool(testAccount, defaultPoolParams, defaultPoolAssets, defaultFutureGovernor), emptySender: false, expectPass: true, }, { name: "create pool with no assets", - msg: balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], defaultPoolParams, defaultPoolAssets, defaultFutureGovernor), + msg: balancer.NewMsgCreateBalancerPool(testAccount, defaultPoolParams, defaultPoolAssets, defaultFutureGovernor), emptySender: true, expectPass: false, }, { name: "create a pool with negative swap fee", - msg: balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], balancer.PoolParams{ + msg: balancer.NewMsgCreateBalancerPool(testAccount, balancer.PoolParams{ SwapFee: sdk.NewDecWithPrec(-1, 2), ExitFee: sdk.NewDecWithPrec(1, 2), }, defaultPoolAssets, defaultFutureGovernor), @@ -74,7 +75,7 @@ func (suite *KeeperTestSuite) TestCreateBalancerPool() { expectPass: false, }, { name: "create a pool with negative exit fee", - msg: balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], balancer.PoolParams{ + msg: balancer.NewMsgCreateBalancerPool(testAccount, balancer.PoolParams{ SwapFee: sdk.NewDecWithPrec(1, 2), ExitFee: sdk.NewDecWithPrec(-1, 2), }, defaultPoolAssets, defaultFutureGovernor), @@ -82,7 +83,7 @@ func (suite *KeeperTestSuite) TestCreateBalancerPool() { expectPass: false, }, { name: "create the pool with empty PoolAssets", - msg: balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], balancer.PoolParams{ + msg: balancer.NewMsgCreateBalancerPool(testAccount, balancer.PoolParams{ SwapFee: sdk.NewDecWithPrec(1, 2), ExitFee: sdk.NewDecWithPrec(1, 2), }, []balancertypes.PoolAsset{}, defaultFutureGovernor), @@ -90,7 +91,7 @@ func (suite *KeeperTestSuite) TestCreateBalancerPool() { expectPass: false, }, { name: "create the pool with 0 weighted PoolAsset", - msg: balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], balancer.PoolParams{ + msg: balancer.NewMsgCreateBalancerPool(testAccount, balancer.PoolParams{ SwapFee: sdk.NewDecWithPrec(1, 2), ExitFee: sdk.NewDecWithPrec(1, 2), }, []balancertypes.PoolAsset{{ @@ -104,7 +105,7 @@ func (suite *KeeperTestSuite) TestCreateBalancerPool() { expectPass: false, }, { name: "create the pool with negative weighted PoolAsset", - msg: balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], balancer.PoolParams{ + msg: balancer.NewMsgCreateBalancerPool(testAccount, balancer.PoolParams{ SwapFee: sdk.NewDecWithPrec(1, 2), ExitFee: sdk.NewDecWithPrec(1, 2), }, []balancertypes.PoolAsset{{ @@ -118,7 +119,7 @@ func (suite *KeeperTestSuite) TestCreateBalancerPool() { expectPass: false, }, { name: "create the pool with 0 balance PoolAsset", - msg: balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], balancer.PoolParams{ + msg: balancer.NewMsgCreateBalancerPool(testAccount, balancer.PoolParams{ SwapFee: sdk.NewDecWithPrec(1, 2), ExitFee: sdk.NewDecWithPrec(1, 2), }, []balancertypes.PoolAsset{{ @@ -132,7 +133,7 @@ func (suite *KeeperTestSuite) TestCreateBalancerPool() { expectPass: false, }, { name: "create the pool with negative balance PoolAsset", - msg: balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], balancer.PoolParams{ + msg: balancer.NewMsgCreateBalancerPool(testAccount, balancer.PoolParams{ SwapFee: sdk.NewDecWithPrec(1, 2), ExitFee: sdk.NewDecWithPrec(1, 2), }, []balancertypes.PoolAsset{{ @@ -149,7 +150,7 @@ func (suite *KeeperTestSuite) TestCreateBalancerPool() { expectPass: false, }, { name: "create the pool with duplicated PoolAssets", - msg: balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], balancer.PoolParams{ + msg: balancer.NewMsgCreateBalancerPool(testAccount, balancer.PoolParams{ SwapFee: sdk.NewDecWithPrec(1, 2), ExitFee: sdk.NewDecWithPrec(1, 2), }, []balancertypes.PoolAsset{{ @@ -166,7 +167,9 @@ func (suite *KeeperTestSuite) TestCreateBalancerPool() { for _, test := range tests { suite.SetupTest() - keeper := suite.App.GAMMKeeper + gammKeeper := suite.App.GAMMKeeper + distributionKeeper := suite.App.DistrKeeper + bankKeeper := suite.App.BankKeeper // fund sender test account sender, err := sdk.AccAddressFromBech32(test.msg.Sender) @@ -176,24 +179,24 @@ func (suite *KeeperTestSuite) TestCreateBalancerPool() { } // note starting balances for community fee pool and pool creator account - feePoolBalBeforeNewPool := suite.App.DistrKeeper.GetFeePoolCommunityCoins(suite.Ctx) - senderBalBeforeNewPool := suite.App.BankKeeper.GetAllBalances(suite.Ctx, sender) + feePoolBalBeforeNewPool := distributionKeeper.GetFeePoolCommunityCoins(suite.Ctx) + senderBalBeforeNewPool := bankKeeper.GetAllBalances(suite.Ctx, sender) // attempt to create a pool with the given NewMsgCreateBalancerPool message - poolId, err := keeper.CreatePool(suite.Ctx, test.msg) + poolId, err := gammKeeper.CreatePool(suite.Ctx, test.msg) if test.expectPass { suite.Require().NoError(err, "test: %v", test.name) // check to make sure new pool exists and has minted the correct number of pool shares - pool, err := keeper.GetPoolAndPoke(suite.Ctx, poolId) + pool, err := gammKeeper.GetPoolAndPoke(suite.Ctx, poolId) suite.Require().NoError(err, "test: %v", test.name) suite.Require().Equal(types.InitPoolSharesSupply.String(), pool.GetTotalShares().String(), fmt.Sprintf("share token should be minted as %s initially", types.InitPoolSharesSupply.String()), ) // make sure pool creation fee is correctly sent to community pool - feePool := suite.App.DistrKeeper.GetFeePoolCommunityCoins(suite.Ctx) + feePool := distributionKeeper.GetFeePoolCommunityCoins(suite.Ctx) suite.Require().Equal(feePool, feePoolBalBeforeNewPool.Add(poolCreationFeeDecCoins...)) // get expected tokens in new pool and corresponding pool shares @@ -204,12 +207,12 @@ func (suite *KeeperTestSuite) TestCreateBalancerPool() { expectedPoolShares := sdk.NewCoin(types.GetPoolShareDenom(pool.GetId()), types.InitPoolSharesSupply) // make sure sender's balance is updated correctly - senderBal := suite.App.BankKeeper.GetAllBalances(suite.Ctx, sender) + senderBal := bankKeeper.GetAllBalances(suite.Ctx, sender) expectedSenderBal := senderBalBeforeNewPool.Sub(params.PoolCreationFee).Sub(expectedPoolTokens).Add(expectedPoolShares) suite.Require().Equal(senderBal.String(), expectedSenderBal.String()) // check pool's liquidity is correctly increased - liquidity := suite.App.GAMMKeeper.GetTotalLiquidity(suite.Ctx) + liquidity := gammKeeper.GetTotalLiquidity(suite.Ctx) suite.Require().Equal(expectedPoolTokens.String(), liquidity.String()) } else { suite.Require().Error(err, "test: %v", test.name) @@ -261,10 +264,12 @@ func (suite *KeeperTestSuite) TestPoolCreationFee() { for _, test := range tests { suite.SetupTest() - keeper := suite.App.GAMMKeeper + gammKeeper := suite.App.GAMMKeeper + distributionKeeper := suite.App.DistrKeeper + bankKeeper := suite.App.BankKeeper // set pool creation fee - keeper.SetParams(suite.Ctx, types.Params{ + gammKeeper.SetParams(suite.Ctx, types.Params{ PoolCreationFee: test.poolCreationFee, }) @@ -274,24 +279,24 @@ func (suite *KeeperTestSuite) TestPoolCreationFee() { suite.FundAcc(sender, defaultAcctFunds) // note starting balances for community fee pool and pool creator account - feePoolBalBeforeNewPool := suite.App.DistrKeeper.GetFeePoolCommunityCoins(suite.Ctx) - senderBalBeforeNewPool := suite.App.BankKeeper.GetAllBalances(suite.Ctx, sender) + feePoolBalBeforeNewPool := distributionKeeper.GetFeePoolCommunityCoins(suite.Ctx) + senderBalBeforeNewPool := bankKeeper.GetAllBalances(suite.Ctx, sender) // attempt to create a pool with the given NewMsgCreateBalancerPool message - poolId, err := keeper.CreatePool(suite.Ctx, test.msg) + poolId, err := gammKeeper.CreatePool(suite.Ctx, test.msg) if test.expectPass { suite.Require().NoError(err, "test: %v", test.name) // check to make sure new pool exists and has minted the correct number of pool shares - pool, err := keeper.GetPoolAndPoke(suite.Ctx, poolId) + pool, err := gammKeeper.GetPoolAndPoke(suite.Ctx, poolId) suite.Require().NoError(err, "test: %v", test.name) suite.Require().Equal(types.InitPoolSharesSupply.String(), pool.GetTotalShares().String(), fmt.Sprintf("share token should be minted as %s initially", types.InitPoolSharesSupply.String()), ) // make sure pool creation fee is correctly sent to community pool - feePool := suite.App.DistrKeeper.GetFeePoolCommunityCoins(suite.Ctx) + feePool := distributionKeeper.GetFeePoolCommunityCoins(suite.Ctx) suite.Require().Equal(feePool, feePoolBalBeforeNewPool.Add(sdk.NewDecCoinsFromCoins(test.poolCreationFee...)...)) // get expected tokens in new pool and corresponding pool shares expectedPoolTokens := sdk.Coins{} @@ -301,12 +306,12 @@ func (suite *KeeperTestSuite) TestPoolCreationFee() { expectedPoolShares := sdk.NewCoin(types.GetPoolShareDenom(pool.GetId()), types.InitPoolSharesSupply) // make sure sender's balance is updated correctly - senderBal := suite.App.BankKeeper.GetAllBalances(suite.Ctx, sender) + senderBal := bankKeeper.GetAllBalances(suite.Ctx, sender) expectedSenderBal := senderBalBeforeNewPool.Sub(test.poolCreationFee).Sub(expectedPoolTokens).Add(expectedPoolShares) suite.Require().Equal(senderBal.String(), expectedSenderBal.String()) // check pool's liquidity is correctly increased - liquidity := suite.App.GAMMKeeper.GetTotalLiquidity(suite.Ctx) + liquidity := gammKeeper.GetTotalLiquidity(suite.Ctx) suite.Require().Equal(expectedPoolTokens.String(), liquidity.String()) } else { suite.Require().Error(err, "test: %v", test.name) @@ -378,42 +383,44 @@ func (suite *KeeperTestSuite) TestJoinPoolNoSwap() { suite.SetupTest() ctx := suite.Ctx - keeper := suite.App.GAMMKeeper + gammKeeper := suite.App.GAMMKeeper + bankKeeper := suite.App.BankKeeper + testAccount := suite.TestAccs[0] // Mint some assets to the accounts. - suite.FundAcc(suite.TestAccs[0], defaultAcctFunds) + suite.FundAcc(testAccount, defaultAcctFunds) // Create the pool at first - msg := balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], balancer.PoolParams{ + msg := balancer.NewMsgCreateBalancerPool(testAccount, balancer.PoolParams{ SwapFee: sdk.NewDecWithPrec(1, 2), ExitFee: sdk.NewDecWithPrec(1, 2), }, defaultPoolAssets, defaultFutureGovernor) - poolId, err := suite.App.GAMMKeeper.CreatePool(suite.Ctx, msg) + poolId, err := gammKeeper.CreatePool(suite.Ctx, msg) suite.Require().NoError(err, "test: %v", test.name) suite.FundAcc(test.txSender, defaultAcctFunds) - balancesBefore := suite.App.BankKeeper.GetAllBalances(suite.Ctx, test.txSender) - _, _, err = keeper.JoinPoolNoSwap(suite.Ctx, test.txSender, poolId, test.sharesRequested, test.tokenInMaxs) + balancesBefore := bankKeeper.GetAllBalances(suite.Ctx, test.txSender) + _, _, err = gammKeeper.JoinPoolNoSwap(suite.Ctx, test.txSender, poolId, test.sharesRequested, test.tokenInMaxs) if test.expectPass { suite.Require().NoError(err, "test: %v", test.name) - suite.Require().Equal(test.sharesRequested.String(), suite.App.BankKeeper.GetBalance(suite.Ctx, test.txSender, "gamm/pool/1").Amount.String()) - balancesAfter := suite.App.BankKeeper.GetAllBalances(suite.Ctx, test.txSender) + suite.Require().Equal(test.sharesRequested.String(), bankKeeper.GetBalance(suite.Ctx, test.txSender, "gamm/pool/1").Amount.String()) + balancesAfter := bankKeeper.GetAllBalances(suite.Ctx, test.txSender) deltaBalances, _ := balancesBefore.SafeSub(balancesAfter) // The pool was created with the 10000foo, 10000bar, and the pool share was minted as 100000000gamm/pool/1. // Thus, to get the 50*OneShare gamm/pool/1, (10000foo, 10000bar) * (1 / 2) balances should be provided. suite.Require().Equal("5000", deltaBalances.AmountOf("foo").String()) suite.Require().Equal("5000", deltaBalances.AmountOf("bar").String()) - liquidity := suite.App.GAMMKeeper.GetTotalLiquidity(suite.Ctx) + liquidity := gammKeeper.GetTotalLiquidity(suite.Ctx) suite.Require().Equal("15000bar,15000foo", liquidity.String()) - assertEventEmitted(suite, ctx, types.TypeEvtPoolJoined, 1) + suite.AssertEventEmitted(ctx, types.TypeEvtPoolJoined, 1) } else { suite.Require().Error(err, "test: %v", test.name) - assertEventEmitted(suite, ctx, types.TypeEvtPoolJoined, 0) + suite.AssertEventEmitted(ctx, types.TypeEvtPoolJoined, 0) } } } @@ -483,43 +490,50 @@ func (suite *KeeperTestSuite) TestExitPool() { } for _, test := range tests { - suite.SetupTest() + suite.Run(test.name, func() { + suite.SetupTest() + ctx := suite.Ctx - keeper := suite.App.GAMMKeeper + gammKeeper := suite.App.GAMMKeeper + bankKeeper := suite.App.BankKeeper - // Mint assets to the pool creator - suite.FundAcc(test.txSender, defaultAcctFunds) + // Mint assets to the pool creator + suite.FundAcc(test.txSender, defaultAcctFunds) - // Create the pool at first - msg := balancer.NewMsgCreateBalancerPool(test.txSender, balancer.PoolParams{ - SwapFee: sdk.NewDecWithPrec(1, 2), - ExitFee: sdk.NewDec(0), - }, defaultPoolAssets, defaultFutureGovernor) - poolId, err := suite.App.GAMMKeeper.CreatePool(suite.Ctx, msg) + // Create the pool at first + msg := balancer.NewMsgCreateBalancerPool(test.txSender, balancer.PoolParams{ + SwapFee: sdk.NewDecWithPrec(1, 2), + ExitFee: sdk.NewDec(0), + }, defaultPoolAssets, defaultFutureGovernor) + poolId, err := gammKeeper.CreatePool(ctx, msg) - // If we are testing insufficient pool share balances, switch tx sender from pool creator to empty account - if test.emptySender { - test.txSender = suite.TestAccs[1] - } + // If we are testing insufficient pool share balances, switch tx sender from pool creator to empty account + if test.emptySender { + test.txSender = suite.TestAccs[1] + } - balancesBefore := suite.App.BankKeeper.GetAllBalances(suite.Ctx, test.txSender) - _, err = keeper.ExitPool(suite.Ctx, test.txSender, poolId, test.sharesIn, test.tokenOutMins) + balancesBefore := bankKeeper.GetAllBalances(suite.Ctx, test.txSender) + _, err = gammKeeper.ExitPool(ctx, test.txSender, poolId, test.sharesIn, test.tokenOutMins) - if test.expectPass { - suite.Require().NoError(err, "test: %v", test.name) - suite.Require().Equal(test.sharesIn.String(), suite.App.BankKeeper.GetBalance(suite.Ctx, test.txSender, "gamm/pool/1").Amount.String()) - balancesAfter := suite.App.BankKeeper.GetAllBalances(suite.Ctx, test.txSender) - deltaBalances, _ := balancesBefore.SafeSub(balancesAfter) - // The pool was created with the 10000foo, 10000bar, and the pool share was minted as 100*OneShare gamm/pool/1. - // Thus, to refund the 50*OneShare gamm/pool/1, (10000foo, 10000bar) * (1 / 2) balances should be refunded. - suite.Require().Equal("-5000", deltaBalances.AmountOf("foo").String()) - suite.Require().Equal("-5000", deltaBalances.AmountOf("bar").String()) + if test.expectPass { + suite.Require().NoError(err, "test: %v", test.name) + suite.Require().Equal(test.sharesIn.String(), bankKeeper.GetBalance(suite.Ctx, test.txSender, "gamm/pool/1").Amount.String()) + balancesAfter := bankKeeper.GetAllBalances(suite.Ctx, test.txSender) + deltaBalances, _ := balancesBefore.SafeSub(balancesAfter) + // The pool was created with the 10000foo, 10000bar, and the pool share was minted as 100*OneShare gamm/pool/1. + // Thus, to refund the 50*OneShare gamm/pool/1, (10000foo, 10000bar) * (1 / 2) balances should be refunded. + suite.Require().Equal("-5000", deltaBalances.AmountOf("foo").String()) + suite.Require().Equal("-5000", deltaBalances.AmountOf("bar").String()) - liquidity := suite.App.GAMMKeeper.GetTotalLiquidity(suite.Ctx) - suite.Require().Equal("5000bar,5000foo", liquidity.String()) - } else { - suite.Require().Error(err, "test: %v", test.name) - } + liquidity := gammKeeper.GetTotalLiquidity(ctx) + suite.Require().Equal("5000bar,5000foo", liquidity.String()) + + suite.AssertEventEmitted(ctx, types.TypeEvtPoolExited, 1) + } else { + suite.Require().Error(err, "test: %v", test.name) + suite.AssertEventEmitted(ctx, types.TypeEvtPoolExited, 0) + } + }) } } @@ -572,6 +586,7 @@ func (suite *KeeperTestSuite) TestJoinPoolExitPool_InverseRelationship() { suite.Run(tc.name, func() { ctx := suite.Ctx + gammKeeper := suite.App.GAMMKeeper for _, acc := range suite.TestAccs { suite.FundAcc(acc, defaultAcctFunds) @@ -583,17 +598,19 @@ func (suite *KeeperTestSuite) TestJoinPoolExitPool_InverseRelationship() { // test account is set on every test case iteration, we need to manually update address for pool creator tc.pool.Sender = createPoolAcc.String() - poolId, err := suite.App.GAMMKeeper.CreatePool(ctx, tc.pool) + poolId, err := gammKeeper.CreatePool(ctx, tc.pool) suite.Require().NoError(err) balanceBeforeJoin := suite.App.BankKeeper.GetAllBalances(ctx, joinPoolAcc) - _, _, err = suite.App.GAMMKeeper.JoinPoolNoSwap(ctx, joinPoolAcc, poolId, tc.joinPoolShareAmt, sdk.Coins{}) + _, _, err = gammKeeper.JoinPoolNoSwap(ctx, joinPoolAcc, poolId, tc.joinPoolShareAmt, sdk.Coins{}) suite.Require().NoError(err) - assertEventEmitted(suite, ctx, types.TypeEvtPoolJoined, 1) + suite.AssertEventEmitted(ctx, types.TypeEvtPoolJoined, 1) + + _, err = gammKeeper.ExitPool(ctx, joinPoolAcc, poolId, tc.joinPoolShareAmt, sdk.Coins{}) - _, err = suite.App.GAMMKeeper.ExitPool(ctx, joinPoolAcc, poolId, tc.joinPoolShareAmt, sdk.Coins{}) + suite.AssertEventEmitted(ctx, types.TypeEvtPoolExited, 1) balanceAfterExit := suite.App.BankKeeper.GetAllBalances(ctx, joinPoolAcc) deltaBalance, _ := balanceBeforeJoin.SafeSub(balanceAfterExit) @@ -615,51 +632,58 @@ func (suite *KeeperTestSuite) TestActiveBalancerPool() { testCases := []testCase{ {time.Unix(1000, 0), true}, - {time.Unix(2000, 0), true}, } for _, tc := range testCases { - suite.SetupTest() + suite.Run("", func() { + suite.SetupTest() - // Mint some assets to the accounts. - for _, acc := range suite.TestAccs { - suite.FundAcc(acc, defaultAcctFunds) + ctx := suite.Ctx + gammKeeper := suite.App.GAMMKeeper + testAccount := suite.TestAccs[0] + + suite.FundAcc(testAccount, defaultAcctFunds) // Create the pool at first poolId := suite.PrepareBalancerPoolWithPoolParams(balancer.PoolParams{ SwapFee: sdk.NewDec(0), ExitFee: sdk.NewDec(0), }) - suite.Ctx = suite.Ctx.WithBlockTime(tc.blockTime) + ctx = ctx.WithBlockTime(tc.blockTime) // uneffected by start time - _, _, err := suite.App.GAMMKeeper.JoinPoolNoSwap(suite.Ctx, suite.TestAccs[0], poolId, types.OneShare.MulRaw(50), sdk.Coins{}) + _, _, err := gammKeeper.JoinPoolNoSwap(ctx, testAccount, poolId, types.OneShare.MulRaw(50), sdk.Coins{}) suite.Require().NoError(err) - _, err = suite.App.GAMMKeeper.ExitPool(suite.Ctx, suite.TestAccs[0], poolId, types.InitPoolSharesSupply.QuoRaw(2), sdk.Coins{}) + + suite.AssertEventEmitted(ctx, types.TypeEvtPoolJoined, 1) + + _, err = gammKeeper.ExitPool(ctx, testAccount, poolId, types.InitPoolSharesSupply.QuoRaw(2), sdk.Coins{}) suite.Require().NoError(err) + suite.AssertEventEmitted(ctx, types.TypeEvtPoolExited, 1) + foocoin := sdk.NewCoin("foo", sdk.NewInt(10)) foocoins := sdk.Coins{foocoin} if tc.expectPass { - _, err = suite.App.GAMMKeeper.JoinSwapExactAmountIn(suite.Ctx, suite.TestAccs[0], poolId, foocoins, sdk.ZeroInt()) + _, err = gammKeeper.JoinSwapExactAmountIn(ctx, testAccount, poolId, foocoins, sdk.ZeroInt()) suite.Require().NoError(err) - _, err = suite.App.GAMMKeeper.JoinSwapShareAmountOut(suite.Ctx, suite.TestAccs[0], poolId, "foo", types.OneShare.MulRaw(10), sdk.NewInt(1000000000000000000)) + _, err = gammKeeper.JoinSwapShareAmountOut(ctx, testAccount, poolId, "foo", types.OneShare.MulRaw(10), sdk.NewInt(1000000000000000000)) suite.Require().NoError(err) - _, err = suite.App.GAMMKeeper.ExitSwapShareAmountIn(suite.Ctx, suite.TestAccs[0], poolId, "foo", types.OneShare.MulRaw(10), sdk.ZeroInt()) + _, err = gammKeeper.ExitSwapShareAmountIn(ctx, testAccount, poolId, "foo", types.OneShare.MulRaw(10), sdk.ZeroInt()) suite.Require().NoError(err) - _, err = suite.App.GAMMKeeper.ExitSwapExactAmountOut(suite.Ctx, suite.TestAccs[0], poolId, foocoin, sdk.NewInt(1000000000000000000)) + _, err = gammKeeper.ExitSwapExactAmountOut(ctx, testAccount, poolId, foocoin, sdk.NewInt(1000000000000000000)) suite.Require().NoError(err) } else { suite.Require().Error(err) - _, err = suite.App.GAMMKeeper.JoinSwapShareAmountOut(suite.Ctx, suite.TestAccs[0], poolId, "foo", types.OneShare.MulRaw(10), sdk.NewInt(1000000000000000000)) + _, err = gammKeeper.JoinSwapShareAmountOut(ctx, testAccount, poolId, "foo", types.OneShare.MulRaw(10), sdk.NewInt(1000000000000000000)) suite.Require().Error(err) - _, err = suite.App.GAMMKeeper.ExitSwapShareAmountIn(suite.Ctx, suite.TestAccs[0], poolId, "foo", types.OneShare.MulRaw(10), sdk.ZeroInt()) + _, err = gammKeeper.ExitSwapShareAmountIn(ctx, testAccount, poolId, "foo", types.OneShare.MulRaw(10), sdk.ZeroInt()) suite.Require().Error(err) - _, err = suite.App.GAMMKeeper.ExitSwapExactAmountOut(suite.Ctx, suite.TestAccs[0], poolId, foocoin, sdk.NewInt(1000000000000000000)) + _, err = gammKeeper.ExitSwapExactAmountOut(ctx, testAccount, poolId, foocoin, sdk.NewInt(1000000000000000000)) suite.Require().Error(err) } - } + }) } } @@ -703,6 +727,8 @@ func (suite *KeeperTestSuite) TestJoinSwapExactAmountInConsistency() { suite.Run(tc.name, func() { suite.SetupTest() ctx := suite.Ctx + gammKeeper := suite.App.GAMMKeeper + testAccount := suite.TestAccs[0] poolID := suite.prepareCustomBalancerPool( defaultAcctFunds, @@ -722,13 +748,13 @@ func (suite *KeeperTestSuite) TestJoinSwapExactAmountInConsistency() { }, ) - shares, err := suite.App.GAMMKeeper.JoinSwapExactAmountIn(ctx, suite.TestAccs[0], poolID, tc.tokensIn, tc.shareOutMinAmount) + shares, err := gammKeeper.JoinSwapExactAmountIn(ctx, testAccount, poolID, tc.tokensIn, tc.shareOutMinAmount) suite.Require().NoError(err) suite.Require().Equal(tc.expectedSharesOut, shares) - tokenOutAmt, err := suite.App.GAMMKeeper.ExitSwapShareAmountIn( + tokenOutAmt, err := gammKeeper.ExitSwapShareAmountIn( ctx, - suite.TestAccs[0], + testAccount, poolID, tc.tokensIn[0].Denom, shares, @@ -801,19 +827,19 @@ func (suite *KeeperTestSuite) TestGetPoolDenom() { // sdk.NewCoin("bar", sdk.NewInt(10000)), // } -// suite.FundAcc(suite.TestAccs[0], defaultAcctFunds) +// suite.FundAcc(testAccount, defaultAcctFunds) // testScalingFactors := []uint64{1, 1} // msg := stableswap.NewMsgCreateStableswapPool( -// suite.TestAccs[0], stableSwapPoolParams, testPoolAsset, defaultFutureGovernor) -// poolID, err := suite.App.GAMMKeeper.CreatePool(suite.Ctx, msg) +// testAccount, stableSwapPoolParams, testPoolAsset, defaultFutureGovernor) +// poolID, err := gammKeeper.CreatePool(suite.Ctx, msg) // suite.Require().NoError(err) -// err = suite.App.GAMMKeeper.SetStableSwapScalingFactors(suite.Ctx, testScalingFactors, poolID, "") +// err = gammKeeper.SetStableSwapScalingFactors(suite.Ctx, testScalingFactors, poolID, "") // suite.Require().NoError(err) -// poolI, err := suite.App.GAMMKeeper.GetPoolAndPoke(suite.Ctx, poolID) +// poolI, err := gammKeeper.GetPoolAndPoke(suite.Ctx, poolID) // suite.Require().NoError(err) // poolScalingFactors := poolI.(*stableswap.Pool).GetScalingFactors() diff --git a/x/gamm/keeper/swap_test.go b/x/gamm/keeper/swap_test.go index a6416198880..2d7048c4b80 100644 --- a/x/gamm/keeper/swap_test.go +++ b/x/gamm/keeper/swap_test.go @@ -103,7 +103,7 @@ func (suite *KeeperTestSuite) TestBalancerPoolSimpleSwapExactAmountIn() { // We consume `types.GasFeeForSwap` directly, so the extra I/O operation mean we end up consuming more. suite.Assert().Greater(gasConsumedForSwap, uint64(types.BalancerGasFeeForSwap)) - assertEventEmitted(suite, ctx, types.TypeEvtTokenSwapped, 1) + suite.AssertEventEmitted(ctx, types.TypeEvtTokenSwapped, 1) spotPriceAfter, err := keeper.CalculateSpotPrice(ctx, poolId, test.param.tokenIn.Denom, test.param.tokenOutDenom) suite.NoError(err, "test: %v", test.name) @@ -213,7 +213,7 @@ func (suite *KeeperTestSuite) TestBalancerPoolSimpleSwapExactAmountOut() { // We consume `types.GasFeeForSwap` directly, so the extra I/O operation mean we end up consuming more. suite.Assert().Greater(gasConsumedForSwap, uint64(types.BalancerGasFeeForSwap)) - assertEventEmitted(suite, ctx, types.TypeEvtTokenSwapped, 1) + suite.AssertEventEmitted(ctx, types.TypeEvtTokenSwapped, 1) spotPriceAfter, err := keeper.CalculateSpotPrice(ctx, poolId, test.param.tokenInDenom, test.param.tokenOut.Denom) suite.NoError(err, "test: %v", test.name) diff --git a/x/superfluid/keeper/unpool_test.go b/x/superfluid/keeper/unpool_test.go index f0a8300a023..332235e993b 100644 --- a/x/superfluid/keeper/unpool_test.go +++ b/x/superfluid/keeper/unpool_test.go @@ -91,13 +91,19 @@ func (suite *KeeperTestSuite) TestUnpool() { tc := tc suite.Run(tc.name, func() { suite.SetupTest() + ctx := suite.Ctx + bankKeeper := suite.App.BankKeeper + gammKeeper := suite.App.GAMMKeeper + superfluidKeeper := suite.App.SuperfluidKeeper + lockupKeeper := suite.App.LockupKeeper + stakingKeeper := suite.App.StakingKeeper // generate one delegator Addr, one gamm pool delAddrs := CreateRandomAccounts(2) poolCreateAcc := delAddrs[0] poolJoinAcc := delAddrs[1] for _, acc := range delAddrs { - err := simapp.FundAccount(suite.App.BankKeeper, suite.Ctx, acc, defaultAcctFunds) + err := simapp.FundAccount(bankKeeper, ctx, acc, defaultAcctFunds) suite.Require().NoError(err) } @@ -110,25 +116,25 @@ func (suite *KeeperTestSuite) TestUnpool() { ExitFee: sdk.NewDec(0), }, defaultPoolAssets, defaultFutureGovernor) - poolId, err := suite.App.GAMMKeeper.CreatePool(suite.Ctx, msg) + poolId, err := gammKeeper.CreatePool(ctx, msg) suite.Require().NoError(err) // join pool - balanceBeforeJoin := suite.App.BankKeeper.GetAllBalances(suite.Ctx, poolJoinAcc) - _, _, err = suite.App.GAMMKeeper.JoinPoolNoSwap(suite.Ctx, poolJoinAcc, poolId, gammtypes.OneShare.MulRaw(50), sdk.Coins{}) + balanceBeforeJoin := bankKeeper.GetAllBalances(ctx, poolJoinAcc) + _, _, err = gammKeeper.JoinPoolNoSwap(ctx, poolJoinAcc, poolId, gammtypes.OneShare.MulRaw(50), sdk.Coins{}) suite.Require().NoError(err) - balanceAfterJoin := suite.App.BankKeeper.GetAllBalances(suite.Ctx, poolJoinAcc) + balanceAfterJoin := bankKeeper.GetAllBalances(ctx, poolJoinAcc) joinPoolAmt, _ := balanceBeforeJoin.SafeSub(balanceAfterJoin) - pool, err := suite.App.GAMMKeeper.GetPoolAndPoke(suite.Ctx, poolId) + pool, err := gammKeeper.GetPoolAndPoke(ctx, poolId) suite.Require().NoError(err) poolDenom := gammtypes.GetPoolShareDenom(pool.GetId()) - poolShareOut := suite.App.BankKeeper.GetBalance(suite.Ctx, poolJoinAcc, poolDenom) + poolShareOut := bankKeeper.GetBalance(ctx, poolJoinAcc, poolDenom) // register a LP token as a superfluid asset - suite.App.SuperfluidKeeper.AddNewSuperfluidAsset(suite.Ctx, types.SuperfluidAsset{ + superfluidKeeper.AddNewSuperfluidAsset(ctx, types.SuperfluidAsset{ Denom: poolDenom, AssetType: types.SuperfluidAssetTypeLPShare, }) @@ -136,10 +142,10 @@ func (suite *KeeperTestSuite) TestUnpool() { // whitelist designated pools // this should be done via `RunForkLogic` at upgrade whitelistedPool := []uint64{poolId} - suite.App.SuperfluidKeeper.SetUnpoolAllowedPools(suite.Ctx, whitelistedPool) + superfluidKeeper.SetUnpoolAllowedPools(ctx, whitelistedPool) coinsToLock := poolShareOut - unbondingDuration := suite.App.StakingKeeper.GetParams(suite.Ctx).UnbondingTime + unbondingDuration := stakingKeeper.GetParams(ctx).UnbondingTime // create lock lockID := suite.LockTokens(poolJoinAcc, sdk.NewCoins(coinsToLock), unbondingDuration) @@ -147,15 +153,15 @@ func (suite *KeeperTestSuite) TestUnpool() { // settings prior to testing for superfluid delegated cases intermediaryAcc := types.SuperfluidIntermediaryAccount{} if tc.superfluidDelegated { - err = suite.App.SuperfluidKeeper.SuperfluidDelegate(suite.Ctx, poolJoinAcc.String(), lockID, valAddr.String()) + err = superfluidKeeper.SuperfluidDelegate(ctx, poolJoinAcc.String(), lockID, valAddr.String()) suite.Require().NoError(err) - intermediaryAccConnection := suite.App.SuperfluidKeeper.GetLockIdIntermediaryAccountConnection(suite.Ctx, lockID) - intermediaryAcc = suite.App.SuperfluidKeeper.GetIntermediaryAccount(suite.Ctx, intermediaryAccConnection) + intermediaryAccConnection := superfluidKeeper.GetLockIdIntermediaryAccountConnection(ctx, lockID) + intermediaryAcc = superfluidKeeper.GetIntermediaryAccount(ctx, intermediaryAccConnection) } // settings prior to testing for superfluid undelegating cases if tc.superfluidUndelegating { - err = suite.App.SuperfluidKeeper.SuperfluidUndelegate(suite.Ctx, poolJoinAcc.String(), lockID) + err = superfluidKeeper.SuperfluidUndelegate(ctx, poolJoinAcc.String(), lockID) suite.Require().NoError(err) } @@ -164,30 +170,32 @@ func (suite *KeeperTestSuite) TestUnpool() { // if lock was superfluid staked, we can't unlock via `BeginUnlock`, // need to unlock lock via `SuperfluidUnbondLock` if tc.superfluidUndelegating { - err = suite.App.SuperfluidKeeper.SuperfluidUnbondLock(suite.Ctx, lockID, poolJoinAcc.String()) + err = superfluidKeeper.SuperfluidUnbondLock(ctx, lockID, poolJoinAcc.String()) suite.Require().NoError(err) } else { - lock, err := suite.App.LockupKeeper.GetLockByID(suite.Ctx, lockID) + lock, err := lockupKeeper.GetLockByID(ctx, lockID) suite.Require().NoError(err) - err = suite.App.LockupKeeper.BeginUnlock(suite.Ctx, lockID, lock.Coins) + err = lockupKeeper.BeginUnlock(ctx, lockID, lock.Coins) suite.Require().NoError(err) // add time to current time to test lock end time - suite.Ctx = suite.Ctx.WithBlockTime(suite.Ctx.BlockTime().Add(time.Hour * 24)) + ctx = ctx.WithBlockTime(ctx.BlockTime().Add(time.Hour * 24)) } } - lock, err := suite.App.LockupKeeper.GetLockByID(suite.Ctx, lockID) + lock, err := lockupKeeper.GetLockByID(ctx, lockID) suite.Require().NoError(err) // run unpooling logic - newLockIDs, err := suite.App.SuperfluidKeeper.UnpoolAllowedPools(suite.Ctx, poolJoinAcc, poolId, lockID) + newLockIDs, err := superfluidKeeper.UnpoolAllowedPools(ctx, poolJoinAcc, poolId, lockID) suite.Require().NoError(err) + suite.AssertEventEmitted(ctx, gammtypes.TypeEvtPoolExited, 1) + cumulativeNewLockCoins := sdk.NewCoins() for _, newLockId := range newLockIDs { - newLock, err := suite.App.LockupKeeper.GetLockByID(suite.Ctx, newLockId) + newLock, err := lockupKeeper.GetLockByID(ctx, newLockId) suite.Require().NoError(err) // check lock end time has been preserved after unpooling @@ -196,7 +204,7 @@ func (suite *KeeperTestSuite) TestUnpool() { if tc.unlocking { suite.Require().Equal(lock.EndTime, newLock.EndTime) } else { - suite.Require().Equal(suite.Ctx.BlockTime().Add(unbondingDuration), newLock.EndTime) + suite.Require().Equal(ctx.BlockTime().Add(unbondingDuration), newLock.EndTime) } cumulativeNewLockCoins = cumulativeNewLockCoins.Add(newLock.Coins...) @@ -215,29 +223,29 @@ func (suite *KeeperTestSuite) TestUnpool() { suite.Require().True(cumulativeNewLockCoins.AmountOf(sdk.DefaultBondDenom).LTE(roundUpTolerance.AmountOf(sdk.DefaultBondDenom))) // check if old lock is deleted - _, err = suite.App.LockupKeeper.GetLockByID(suite.Ctx, lockID) + _, err = lockupKeeper.GetLockByID(ctx, lockID) suite.Require().Error(err) // check for locks that were superfluid staked. if tc.superfluidDelegated { // check if unpooling deleted intermediary account connection - addr := suite.App.SuperfluidKeeper.GetLockIdIntermediaryAccountConnection(suite.Ctx, lockID) + addr := superfluidKeeper.GetLockIdIntermediaryAccountConnection(ctx, lockID) suite.Require().Equal(addr.String(), "") // check bonding synthetic lockup deletion - _, err = suite.App.LockupKeeper.GetSyntheticLockup(suite.Ctx, lockID, keeper.StakingSyntheticDenom(lock.Coins[0].Denom, valAddr.String())) + _, err = lockupKeeper.GetSyntheticLockup(ctx, lockID, keeper.StakingSyntheticDenom(lock.Coins[0].Denom, valAddr.String())) suite.Require().Error(err) // check unbonding synthetic lockup creation - // unbondingDuration := suite.App.StakingKeeper.GetParams(suite.Ctx).UnbondingTime - // synthLock, err := suite.App.LockupKeeper.GetSyntheticLockup(suite.Ctx, lockID, keeper.UnstakingSyntheticDenom(lock.Coins[0].Denom, valAddr.String())) + // unbondingDuration := stakingKeeper.GetParams(ctx).UnbondingTime + // synthLock, err := lockupKeeper.GetSyntheticLockup(ctx, lockID, keeper.UnstakingSyntheticDenom(lock.Coins[0].Denom, valAddr.String())) // suite.Require().NoError(err) // suite.Require().Equal(synthLock.UnderlyingLockId, lockID) // suite.Require().Equal(synthLock.SynthDenom, keeper.UnstakingSyntheticDenom(lock.Coins[0].Denom, valAddr.String())) - // suite.Require().Equal(synthLock.EndTime, suite.Ctx.BlockTime().Add(unbondingDuration)) + // suite.Require().Equal(synthLock.EndTime, ctx.BlockTime().Add(unbondingDuration)) // check if delegation has reduced from intermediary account - delegation, found := suite.App.StakingKeeper.GetDelegation(suite.Ctx, intermediaryAcc.GetAccAddress(), valAddr) + delegation, found := stakingKeeper.GetDelegation(ctx, intermediaryAcc.GetAccAddress(), valAddr) suite.Require().False(found, "expected no delegation, found delegation w/ %d shares", delegation.Shares) } })