[Tradeshield]: Fix batch execution issue (#1286)

* test

* fix

Author: amityadav0

x/tradeshield/keeper/msg_server_execute_order_test.go

@@ -180,6 +180,82 @@ func (suite *TradeshieldKeeperTestSuite) TestMsgServerExecuteOrder() {
 				}
 			},
 		},
+		{
+			"Success: Execute Multiple Spot Orders with One Failure",
+			"",
+			func() *types.MsgExecuteOrders {
+				suite.ResetSuite()
+				suite.SetupCoinPrices()
+
+				addr = suite.AddAccounts(1, addr)
+				_ = suite.CreateNewAmmPool(addr[0], true, math.LegacyZeroDec(), math.LegacyZeroDec(), ptypes.ATOM, math.NewInt(100000000000).MulRaw(10), math.NewInt(100000000000).MulRaw(10))
+
+				openOrderMsg1 := &types.MsgCreateSpotOrder{
+					OwnerAddress:     addr[2].String(),
+					OrderType:        types.SpotOrderType_LIMITBUY,
+					OrderPrice:       math.LegacyNewDec(10),
+					OrderAmount:      sdk.NewCoin("uusdc", math.NewInt(100000)),
+					OrderTargetDenom: "uatom",
+				}
+				msgSrvr := keeper.NewMsgServerImpl(suite.app.TradeshieldKeeper)
+				_, err := msgSrvr.CreateSpotOrder(suite.ctx, openOrderMsg1)
+				suite.Require().NoError(err)
+
+				openOrderMsg2 := &types.MsgCreateSpotOrder{
+					OwnerAddress:     addr[2].String(),
+					OrderType:        types.SpotOrderType_LIMITSELL,
+					OrderPrice:       math.LegacyNewDec(10),
+					OrderAmount:      sdk.NewCoin("uusdc", math.NewInt(200000)),
+					OrderTargetDenom: "uatom",
+				}
+				_, err = msgSrvr.CreateSpotOrder(suite.ctx, openOrderMsg2)
+				suite.Require().NoError(err)
+
+				suite.app.OracleKeeper.SetPrice(suite.ctx, oracletypes.Price{
+					Asset:     "ATOM",
+					Price:     math.LegacyNewDec(5),
+					Source:    "elys",
+					Provider:  oracleProvider.String(),
+					Timestamp: uint64(suite.ctx.BlockTime().Unix()),
+				})
+
+				// Return message with both order IDs
+				return &types.MsgExecuteOrders{
+					Creator:           addr[2].String(),
+					SpotOrderIds:      []uint64{1, 2}, // Both orders exist but second will fail during execution
+					PerpetualOrderIds: []uint64{},
+				}
+			},
+			func() {
+				// Get events from context
+				events := suite.ctx.EventManager().Events()
+
+				// Find the specific event we're looking for
+				var foundEvent sdk.Event
+				for _, event := range events {
+					if event.Type == types.TypeEvtExecuteLimitBuySpotOrder {
+						foundEvent = event
+						break
+					}
+				}
+
+				// Assert event was emitted for the successful order
+				suite.Require().NotNil(foundEvent)
+
+				// Check event attributes
+				suite.Require().Equal(types.TypeEvtExecuteLimitBuySpotOrder, foundEvent.Type)
+
+				// Check specific attributes
+				for _, attr := range foundEvent.Attributes {
+					switch string(attr.Key) {
+					case "order_id":
+						suite.Require().Equal("1", string(attr.Value))
+					case "order_price":
+						suite.Require().Equal(string(attr.Value), "\"10.000000000000000000\"")
+					}
+				}
+			},
+		},
 	}
 
 	for _, tc := range testCases {

x/tradeshield/keeper/pending_spot_order.go

@@ -276,6 +276,9 @@ func (k Keeper) ExecuteLimitSellOrder(ctx sdk.Context, order types.SpotOrder) (*
 		MinAmount: sdk.NewCoin(order.OrderTargetDenom, sdkmath.ZeroInt()),
 		MaxAmount: order.OrderAmount,
 	})
+	if err != nil {
+		return res, err
+	}
 
 	params := k.GetParams(ctx)
 	expectedAmount := marketPrice.Mul(osmomath.BigDecFromSDKInt(order.OrderAmount.Amount))
@@ -289,9 +292,6 @@ func (k Keeper) ExecuteLimitSellOrder(ctx sdk.Context, order types.SpotOrder) (*
 	if tolerance.GT(params.GetBigDecTolerance()) {
 		return res, errorsmod.Wrapf(types.ErrHighTolerance, "tolerance: %s", tolerance)
 	}
-	if err != nil {
-		return res, err
-	}
 
 	// Remove the order from the pending order list
 	k.RemovePendingSpotOrder(ctx, order.OrderId)
@@ -334,6 +334,9 @@ func (k Keeper) ExecuteLimitBuyOrder(ctx sdk.Context, order types.SpotOrder) (*a
 		MinAmount: sdk.NewCoin(order.OrderTargetDenom, sdkmath.ZeroInt()),
 		MaxAmount: order.OrderAmount,
 	})
+	if err != nil {
+		return res, err
+	}
 
 	params := k.GetParams(ctx)
 	expectedAmount := osmomath.BigDecFromSDKInt(order.OrderAmount.Amount).Quo(marketPrice)
@@ -347,9 +350,6 @@ func (k Keeper) ExecuteLimitBuyOrder(ctx sdk.Context, order types.SpotOrder) (*a
 	if tolerance.GT(params.GetBigDecTolerance()) {
 		return res, errorsmod.Wrapf(types.ErrHighTolerance, "tolerance: %s", tolerance)
 	}
-	if err != nil {
-		return res, err
-	}
 
 	// Remove the order from the pending order list
 	k.RemovePendingSpotOrder(ctx, order.OrderId)