feat: implement x/liquidity simulations and fix bugs

Merge pull request #141 from cosmosquad-labs/liquidity-simulation

app/app.go

@@ -540,7 +540,7 @@ func NewSquadApp(
 		authzmodule.NewAppModule(appCodec, app.AuthzKeeper, app.AccountKeeper, app.BankKeeper, app.interfaceRegistry),
 		ibc.NewAppModule(app.IBCKeeper),
 		params.NewAppModule(app.ParamsKeeper),
-		liquidity.NewAppModule(appCodec, app.LiquidityKeeper),
+		liquidity.NewAppModule(appCodec, app.LiquidityKeeper, app.AccountKeeper, app.BankKeeper),
 		farming.NewAppModule(appCodec, app.FarmingKeeper, app.AccountKeeper, app.BankKeeper),
 		liquidstaking.NewAppModule(appCodec, app.LiquidStakingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper, app.DistrKeeper, app.GovKeeper),
 		claim.NewAppModule(appCodec, app.ClaimKeeper, app.AccountKeeper, app.BankKeeper),
@@ -629,7 +629,7 @@ func NewSquadApp(
 		slashing.NewAppModule(appCodec, app.SlashingKeeper, app.AccountKeeper, app.BankKeeper, *app.StakingKeeper),
 		params.NewAppModule(app.ParamsKeeper),
 		evidence.NewAppModule(app.EvidenceKeeper),
-		liquidity.NewAppModule(appCodec, app.LiquidityKeeper),
+		liquidity.NewAppModule(appCodec, app.LiquidityKeeper, app.AccountKeeper, app.BankKeeper),
 		liquidstaking.NewAppModule(appCodec, app.LiquidStakingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper, app.DistrKeeper, app.GovKeeper),
 		ibc.NewAppModule(app.IBCKeeper),
 		app.transferModule,

app/params/weights.go

@@ -1,13 +1,22 @@
 package params
 
+// Default simulation operation weights for messages and gov proposals.
 const (
-	// farming module simulation operation weights for messages
 	DefaultWeightMsgCreateFixedAmountPlan int = 10
 	DefaultWeightMsgCreateRatioPlan       int = 10
 	DefaultWeightMsgStake                 int = 85
 	DefaultWeightMsgUnstake               int = 30
 	DefaultWeightMsgHarvest               int = 30
 
+	DefaultWeightMsgCreatePair      int = 10
+	DefaultWeightMsgCreatePool      int = 15
+	DefaultWeightMsgDeposit         int = 20
+	DefaultWeightMsgWithdraw        int = 20
+	DefaultWeightMsgLimitOrder      int = 80
+	DefaultWeightMsgMarketOrder     int = 60
+	DefaultWeightMsgCancelOrder     int = 20
+	DefaultWeightMsgCancelAllOrders int = 20
+
 	DefaultWeightAddPublicPlanProposal    int = 5
 	DefaultWeightUpdatePublicPlanProposal int = 5
 	DefaultWeightDeletePublicPlanProposal int = 5

x/liquidity/client/cli/tx.go

@@ -30,10 +30,10 @@ func GetTxCmd() *cobra.Command {
 	cmd.AddCommand(
 		NewCreatePairCmd(),
 		NewCreatePoolCmd(),
-		NewDepositBatchCmd(),
-		NewWithdrawBatchCmd(),
-		NewLimitOrderBatchCmd(),
-		NewMarketOrderBatchCmd(),
+		NewDepositCmd(),
+		NewWithdrawCmd(),
+		NewLimitOrderCmd(),
+		NewMarketOrderCmd(),
 		NewCancelOrderCmd(),
 		NewCancelAllOrdersCmd(),
 	)
@@ -114,7 +114,7 @@ $ %s tx %s create-pool 1 1000000000uatom,50000000000usquad --from mykey
 	return cmd
 }
 
-func NewDepositBatchCmd() *cobra.Command {
+func NewDepositCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "deposit [pool-id] [deposit-coins]",
 		Args:  cobra.ExactArgs(2),
@@ -154,7 +154,7 @@ $ %s tx %s deposit 1 1000000000uatom,50000000000usquad --from mykey
 	return cmd
 }
 
-func NewWithdrawBatchCmd() *cobra.Command {
+func NewWithdrawCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "withdraw [pool-id] [pool-coin]",
 		Args:  cobra.ExactArgs(2),
@@ -198,7 +198,7 @@ $ %s tx %s withdraw 1 10000pool1 --from mykey
 	return cmd
 }
 
-func NewLimitOrderBatchCmd() *cobra.Command {
+func NewLimitOrderCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "limit-order [pair-id] [direction] [offer-coin] [demand-coin-denom] [price] [base-coin-amount] [order-lifespan]",
 		Args:  cobra.ExactArgs(7),
@@ -284,7 +284,7 @@ $ %s tx %s limit-order 1 SWAP_DIRECTION_BUY 10000usquad uatom 1.0 10000 10s --fr
 	return cmd
 }
 
-func NewMarketOrderBatchCmd() *cobra.Command {
+func NewMarketOrderCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "market-order [pair-id] [direction] [offer-coin] [demand-coin-denom] [base-coin-amount] [order-lifespan]",
 		Args:  cobra.ExactArgs(6),

x/liquidity/keeper/batch_test.go

@@ -20,11 +20,11 @@ func (s *KeeperTestSuite) TestDepositWithdraw() {
 
 	// A depositor makes a deposit
 	depositor := s.addr(1)
-	s.depositBatch(depositor, pool.Id, parseCoins("500000denom1,500000denom2"), true)
+	s.deposit(depositor, pool.Id, parseCoins("500000denom1,500000denom2"), true)
 	s.nextBlock()
 
 	// The depositor withdraws pool coin
 	poolCoin := s.getBalance(depositor, pool.PoolCoinDenom)
-	s.withdrawBatch(depositor, pool.Id, poolCoin)
+	s.withdraw(depositor, pool.Id, poolCoin)
 	s.nextBlock()
 }

x/liquidity/keeper/genesis_test.go

@@ -19,20 +19,20 @@ func (s *KeeperTestSuite) TestImportExportGenesis() {
 	pair := s.createPair(s.addr(0), "denom1", "denom2", true)
 	pool := s.createPool(s.addr(0), pair.Id, parseCoins("1000000denom1,1000000denom2"), true)
 
-	s.depositBatch(s.addr(1), pool.Id, parseCoins("1000000denom1,1000000denom2"), true)
+	s.deposit(s.addr(1), pool.Id, parseCoins("1000000denom1,1000000denom2"), true)
 	s.nextBlock()
 
 	poolCoin := s.getBalance(s.addr(1), pool.PoolCoinDenom)
 	poolCoin.Amount = poolCoin.Amount.QuoRaw(2)
-	s.withdrawBatch(s.addr(1), pool.Id, poolCoin)
+	s.withdraw(s.addr(1), pool.Id, poolCoin)
 	s.nextBlock()
 
-	s.buyLimitOrderBatch(s.addr(2), pair.Id, parseDec("1.0"), newInt(10000), 0, true)
+	s.buyLimitOrder(s.addr(2), pair.Id, parseDec("1.0"), newInt(10000), 0, true)
 	s.nextBlock()
 
-	depositReq := s.depositBatch(s.addr(3), pool.Id, parseCoins("1000000denom1,1000000denom2"), true)
-	withdrawReq := s.withdrawBatch(s.addr(1), pool.Id, poolCoin)
-	swapReq := s.sellLimitOrderBatch(s.addr(3), pair.Id, parseDec("1.0"), newInt(1000), 0, true)
+	depositReq := s.deposit(s.addr(3), pool.Id, parseCoins("1000000denom1,1000000denom2"), true)
+	withdrawReq := s.withdraw(s.addr(1), pool.Id, poolCoin)
+	swapReq := s.sellLimitOrder(s.addr(3), pair.Id, parseDec("1.0"), newInt(1000), 0, true)
 
 	genState := k.ExportGenesis(ctx)
 

x/liquidity/keeper/grpc_query_test.go

@@ -395,10 +395,10 @@ func (s *KeeperTestSuite) TestGRPCDepositRequests() {
 	pool := s.createPool(creator, pair.Id, parseCoins("5000000denom1,5000000denom2"), true)
 
 	depositor := s.addr(1)
-	s.depositBatch(depositor, pool.Id, parseCoins("250000denom1,250000denom2"), true)
-	s.depositBatch(depositor, pool.Id, parseCoins("250000denom1,250000denom2"), true)
-	s.depositBatch(depositor, pool.Id, parseCoins("250000denom1,250000denom2"), true)
-	s.depositBatch(depositor, pool.Id, parseCoins("250000denom1,250000denom2"), true)
+	s.deposit(depositor, pool.Id, parseCoins("250000denom1,250000denom2"), true)
+	s.deposit(depositor, pool.Id, parseCoins("250000denom1,250000denom2"), true)
+	s.deposit(depositor, pool.Id, parseCoins("250000denom1,250000denom2"), true)
+	s.deposit(depositor, pool.Id, parseCoins("250000denom1,250000denom2"), true)
 	liquidity.EndBlocker(s.ctx, s.keeper)
 
 	for _, tc := range []struct {
@@ -458,7 +458,7 @@ func (s *KeeperTestSuite) TestGRPCDepositRequest() {
 	pool := s.createPool(creator, pair.Id, parseCoins("5000000denom1,5000000denom2"), true)
 
 	depositor := s.addr(1)
-	req := s.depositBatch(depositor, pool.Id, parseCoins("250000denom1,250000denom2"), true)
+	req := s.deposit(depositor, pool.Id, parseCoins("250000denom1,250000denom2"), true)
 	liquidity.EndBlocker(s.ctx, s.keeper)
 
 	for _, tc := range []struct {
@@ -527,9 +527,9 @@ func (s *KeeperTestSuite) TestGRPCWithdrawRequests() {
 	poolCoinBalance := s.app.BankKeeper.GetBalance(s.ctx, creator, pool.PoolCoinDenom)
 	s.Require().Equal(params.InitialPoolCoinSupply, poolCoinBalance.Amount)
 
-	s.withdrawBatch(creator, pool.Id, sdk.NewInt64Coin(pool.PoolCoinDenom, 1000))
-	s.withdrawBatch(creator, pool.Id, sdk.NewInt64Coin(pool.PoolCoinDenom, 2500))
-	s.withdrawBatch(creator, pool.Id, sdk.NewInt64Coin(pool.PoolCoinDenom, 6000))
+	s.withdraw(creator, pool.Id, sdk.NewInt64Coin(pool.PoolCoinDenom, 1000))
+	s.withdraw(creator, pool.Id, sdk.NewInt64Coin(pool.PoolCoinDenom, 2500))
+	s.withdraw(creator, pool.Id, sdk.NewInt64Coin(pool.PoolCoinDenom, 6000))
 	liquidity.EndBlocker(s.ctx, s.keeper)
 
 	for _, tc := range []struct {
@@ -588,7 +588,7 @@ func (s *KeeperTestSuite) TestGRPCWithdrawRequest() {
 	pair := s.createPair(creator, "denom1", "denom2", true)
 	pool := s.createPool(creator, pair.Id, parseCoins("5000000denom1,5000000denom2"), true)
 
-	req := s.withdrawBatch(creator, pool.Id, sdk.NewInt64Coin(pool.PoolCoinDenom, 50000))
+	req := s.withdraw(creator, pool.Id, sdk.NewInt64Coin(pool.PoolCoinDenom, 50000))
 	liquidity.EndBlocker(s.ctx, s.keeper)
 
 	for _, tc := range []struct {
@@ -650,11 +650,11 @@ func (s *KeeperTestSuite) TestGRPCSwapRequests() {
 	creator := s.addr(0)
 	pair := s.createPair(creator, "denom1", "denom2", true)
 
-	s.buyLimitOrderBatch(s.addr(1), pair.Id, parseDec("1.0"), sdk.NewInt(1000000), 10*time.Second, true)
-	s.buyLimitOrderBatch(s.addr(1), pair.Id, parseDec("1.0"), sdk.NewInt(5000000), 10*time.Second, true)
-	s.sellLimitOrderBatch(s.addr(2), pair.Id, parseDec("1.0"), newInt(10000), time.Hour, true)
-	s.sellLimitOrderBatch(s.addr(2), pair.Id, parseDec("1.0"), newInt(700000), time.Hour, true)
-	s.buyLimitOrderBatch(s.addr(2), pair.Id, parseDec("1.0"), sdk.NewInt(1000000), 10*time.Second, true)
+	s.buyLimitOrder(s.addr(1), pair.Id, parseDec("1.0"), sdk.NewInt(1000000), 10*time.Second, true)
+	s.buyLimitOrder(s.addr(1), pair.Id, parseDec("1.0"), sdk.NewInt(5000000), 10*time.Second, true)
+	s.sellLimitOrder(s.addr(2), pair.Id, parseDec("1.0"), newInt(10000), time.Hour, true)
+	s.sellLimitOrder(s.addr(2), pair.Id, parseDec("1.0"), newInt(700000), time.Hour, true)
+	s.buyLimitOrder(s.addr(2), pair.Id, parseDec("1.0"), sdk.NewInt(1000000), 10*time.Second, true)
 	liquidity.EndBlocker(s.ctx, s.keeper)
 
 	for _, tc := range []struct {
@@ -701,7 +701,7 @@ func (s *KeeperTestSuite) TestGRPCSwapRequest() {
 	creator := s.addr(0)
 	pair := s.createPair(creator, "denom1", "denom2", true)
 
-	req := s.buyLimitOrderBatch(s.addr(1), pair.Id, parseDec("1.0"), sdk.NewInt(1000000), 10*time.Second, true)
+	req := s.buyLimitOrder(s.addr(1), pair.Id, parseDec("1.0"), sdk.NewInt(1000000), 10*time.Second, true)
 	liquidity.EndBlocker(s.ctx, s.keeper)
 
 	for _, tc := range []struct {

x/liquidity/keeper/invariants_test.go

@@ -8,7 +8,7 @@ func (s *KeeperTestSuite) TestDepositCoinsEscrowInvariant() {
 	pair := s.createPair(s.addr(0), "denom1", "denom2", true)
 	pool := s.createPool(s.addr(0), pair.Id, parseCoins("1000000denom1,1000000denom2"), true)
 
-	req := s.depositBatch(s.addr(1), pool.Id, parseCoins("1000000denom1,1000000denom2"), true)
+	req := s.deposit(s.addr(1), pool.Id, parseCoins("1000000denom1,1000000denom2"), true)
 	_, broken := keeper.DepositCoinsEscrowInvariant(s.keeper)(s.ctx)
 	s.Require().False(broken)
 
@@ -29,10 +29,10 @@ func (s *KeeperTestSuite) TestPoolCoinEscrowInvariant() {
 	pair := s.createPair(s.addr(0), "denom1", "denom2", true)
 	pool := s.createPool(s.addr(0), pair.Id, parseCoins("1000000denom1,1000000denom2"), true)
 
-	s.depositBatch(s.addr(1), pool.Id, parseCoins("1000000denom1,1000000denom2"), true)
+	s.deposit(s.addr(1), pool.Id, parseCoins("1000000denom1,1000000denom2"), true)
 	s.nextBlock()
 
-	req := s.withdrawBatch(s.addr(1), pool.Id, parseCoin("1000000pool1"))
+	req := s.withdraw(s.addr(1), pool.Id, parseCoin("1000000pool1"))
 	_, broken := keeper.PoolCoinEscrowInvariant(s.keeper)(s.ctx)
 	s.Require().False(broken)
 
@@ -52,7 +52,7 @@ func (s *KeeperTestSuite) TestPoolCoinEscrowInvariant() {
 func (s *KeeperTestSuite) TestRemainingOfferCoinEscrowInvariant() {
 	pair := s.createPair(s.addr(0), "denom1", "denom2", true)
 
-	req := s.buyLimitOrderBatch(s.addr(1), pair.Id, parseDec("1.0"), newInt(1000000), 0, true)
+	req := s.buyLimitOrder(s.addr(1), pair.Id, parseDec("1.0"), newInt(1000000), 0, true)
 	_, broken := keeper.RemainingOfferCoinEscrowInvariant(s.keeper)(s.ctx)
 	s.Require().False(broken)
 
@@ -76,7 +76,7 @@ func (s *KeeperTestSuite) TestPoolStatusInvariant() {
 	_, broken := keeper.PoolStatusInvariant(s.keeper)(s.ctx)
 	s.Require().False(broken)
 
-	s.withdrawBatch(s.addr(0), pool.Id, s.getBalance(s.addr(0), pool.PoolCoinDenom))
+	s.withdraw(s.addr(0), pool.Id, s.getBalance(s.addr(0), pool.PoolCoinDenom))
 	s.nextBlock()
 
 	_, broken = keeper.PoolStatusInvariant(s.keeper)(s.ctx)

x/liquidity/keeper/keeper_test.go

@@ -91,22 +91,22 @@ func (s *KeeperTestSuite) createPool(creator sdk.AccAddress, pairId uint64, depo
 	return pool
 }
 
-func (s *KeeperTestSuite) depositBatch(depositor sdk.AccAddress, poolId uint64, depositCoins sdk.Coins, fund bool) types.DepositRequest {
+func (s *KeeperTestSuite) deposit(depositor sdk.AccAddress, poolId uint64, depositCoins sdk.Coins, fund bool) types.DepositRequest {
 	if fund {
 		s.fundAddr(depositor, depositCoins)
 	}
-	req, err := s.keeper.DepositBatch(s.ctx, types.NewMsgDeposit(depositor, poolId, depositCoins))
+	req, err := s.keeper.Deposit(s.ctx, types.NewMsgDeposit(depositor, poolId, depositCoins))
 	s.Require().NoError(err)
 	return req
 }
 
-func (s *KeeperTestSuite) withdrawBatch(withdrawer sdk.AccAddress, poolId uint64, poolCoin sdk.Coin) types.WithdrawRequest {
-	req, err := s.keeper.WithdrawBatch(s.ctx, types.NewMsgWithdraw(withdrawer, poolId, poolCoin))
+func (s *KeeperTestSuite) withdraw(withdrawer sdk.AccAddress, poolId uint64, poolCoin sdk.Coin) types.WithdrawRequest {
+	req, err := s.keeper.Withdraw(s.ctx, types.NewMsgWithdraw(withdrawer, poolId, poolCoin))
 	s.Require().NoError(err)
 	return req
 }
 
-func (s *KeeperTestSuite) limitOrderBatch(
+func (s *KeeperTestSuite) limitOrder(
 	orderer sdk.AccAddress, pairId uint64, dir types.SwapDirection,
 	price sdk.Dec, amt sdk.Int, orderLifespan time.Duration, fund bool) types.SwapRequest {
 	pair, found := s.keeper.GetPair(s.ctx, pairId)
@@ -115,7 +115,7 @@ func (s *KeeperTestSuite) limitOrderBatch(
 	var demandCoinDenom string
 	switch dir {
 	case types.SwapDirectionBuy:
-		offerCoin = sdk.NewCoin(pair.QuoteCoinDenom, price.MulInt(amt).TruncateInt())
+		offerCoin = sdk.NewCoin(pair.QuoteCoinDenom, price.MulInt(amt).Ceil().TruncateInt())
 		demandCoinDenom = pair.BaseCoinDenom
 	case types.SwapDirectionSell:
 		offerCoin = sdk.NewCoin(pair.BaseCoinDenom, amt)
@@ -127,22 +127,22 @@ func (s *KeeperTestSuite) limitOrderBatch(
 	msg := types.NewMsgLimitOrder(
 		orderer, pairId, dir, offerCoin, demandCoinDenom,
 		price, amt, orderLifespan)
-	req, err := s.keeper.LimitOrderBatch(s.ctx, msg)
+	req, err := s.keeper.LimitOrder(s.ctx, msg)
 	s.Require().NoError(err)
 	return req
 }
 
-func (s *KeeperTestSuite) buyLimitOrderBatch(
+func (s *KeeperTestSuite) buyLimitOrder(
 	orderer sdk.AccAddress, pairId uint64, price sdk.Dec,
 	amt sdk.Int, orderLifespan time.Duration, fund bool) types.SwapRequest {
-	return s.limitOrderBatch(
+	return s.limitOrder(
 		orderer, pairId, types.SwapDirectionBuy, price, amt, orderLifespan, fund)
 }
 
-func (s *KeeperTestSuite) sellLimitOrderBatch(
+func (s *KeeperTestSuite) sellLimitOrder(
 	orderer sdk.AccAddress, pairId uint64, price sdk.Dec,
 	amt sdk.Int, orderLifespan time.Duration, fund bool) types.SwapRequest {
-	return s.limitOrderBatch(
+	return s.limitOrder(
 		orderer, pairId, types.SwapDirectionSell, price, amt, orderLifespan, fund)
 }
 

x/liquidity/keeper/msg_server.go

@@ -46,7 +46,7 @@ func (m msgServer) CreatePool(goCtx context.Context, msg *types.MsgCreatePool) (
 func (m msgServer) Deposit(goCtx context.Context, msg *types.MsgDeposit) (*types.MsgDepositResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
-	if _, err := m.Keeper.DepositBatch(ctx, msg); err != nil {
+	if _, err := m.Keeper.Deposit(ctx, msg); err != nil {
 		return nil, err
 	}
 
@@ -57,7 +57,7 @@ func (m msgServer) Deposit(goCtx context.Context, msg *types.MsgDeposit) (*types
 func (m msgServer) Withdraw(goCtx context.Context, msg *types.MsgWithdraw) (*types.MsgWithdrawResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
-	if _, err := m.Keeper.WithdrawBatch(ctx, msg); err != nil {
+	if _, err := m.Keeper.Withdraw(ctx, msg); err != nil {
 		return nil, err
 	}
 
@@ -68,7 +68,7 @@ func (m msgServer) Withdraw(goCtx context.Context, msg *types.MsgWithdraw) (*typ
 func (m msgServer) LimitOrder(goCtx context.Context, msg *types.MsgLimitOrder) (*types.MsgLimitOrderResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
-	if _, err := m.Keeper.LimitOrderBatch(ctx, msg); err != nil {
+	if _, err := m.Keeper.LimitOrder(ctx, msg); err != nil {
 		return nil, err
 	}
 
@@ -79,7 +79,7 @@ func (m msgServer) LimitOrder(goCtx context.Context, msg *types.MsgLimitOrder) (
 func (m msgServer) MarketOrder(goCtx context.Context, msg *types.MsgMarketOrder) (*types.MsgMarketOrderResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
-	if _, err := m.Keeper.MarketOrderBatch(ctx, msg); err != nil {
+	if _, err := m.Keeper.MarketOrder(ctx, msg); err != nil {
 		return nil, err
 	}
 

x/liquidity/keeper/pool.go

@@ -126,8 +126,8 @@ func (k Keeper) CreatePool(ctx sdk.Context, msg *types.MsgCreatePool) (types.Poo
 	return pool, nil
 }
 
-// DepositBatch handles types.MsgDeposit and stores the request.
-func (k Keeper) DepositBatch(ctx sdk.Context, msg *types.MsgDeposit) (types.DepositRequest, error) {
+// Deposit handles types.MsgDeposit and stores the request.
+func (k Keeper) Deposit(ctx sdk.Context, msg *types.MsgDeposit) (types.DepositRequest, error) {
 	pool, found := k.GetPool(ctx, msg.PoolId)
 	if !found {
 		return types.DepositRequest{}, sdkerrors.Wrapf(sdkerrors.ErrNotFound, "pool with id %d not found", msg.PoolId)
@@ -165,8 +165,8 @@ func (k Keeper) DepositBatch(ctx sdk.Context, msg *types.MsgDeposit) (types.Depo
 	return req, nil
 }
 
-// WithdrawBatch handles types.MsgWithdraw and stores the request.
-func (k Keeper) WithdrawBatch(ctx sdk.Context, msg *types.MsgWithdraw) (types.WithdrawRequest, error) {
+// Withdraw handles types.MsgWithdraw and stores the request.
+func (k Keeper) Withdraw(ctx sdk.Context, msg *types.MsgWithdraw) (types.WithdrawRequest, error) {
 	pool, found := k.GetPool(ctx, msg.PoolId)
 	if !found {
 		return types.WithdrawRequest{}, sdkerrors.Wrapf(sdkerrors.ErrNotFound, "pool with id %d not found", msg.PoolId)