User can loose funds in case if swapping in DecreaseOrderUtils.processOrder will fail
When user executes decrease order, then he provides `order.minOutputAmount` value, that should protect his from loses. This value is provided with hope that swapping that will take some fees will be executed. But in case if swapping will fail, then this `order.minOutputAmount` value will be smaller then user would like to receive in case when swapping didn't occur. Because of that user can receive less output amount.\\n`DecreaseOrderUtils.processOrder` function executed decrease order and returns order execution result which contains information about output tokens and amounts that user should receive.\\n```\\n        try params.contracts.swapHandler.swap(\\n            SwapUtils.SwapParams(\\n                params.contracts.dataStore,\\n                params.contracts.eventEmitter,\\n                params.contracts.oracle,\\n                Bank(payable(order.market())),\\n                params.key,\\n                result.outputToken,\\n                result.outputAmount,\\n                params.swapPathMarkets,\\n                0,\\n                order.receiver(),\\n                order.uiFeeReceiver(),\\n                order.shouldUnwrapNativeToken()\\n            )\\n        ) returns (address tokenOut, uint256 swapOutputAmount) {\\n            `(\\n                params.contracts.oracle,\\n                tokenOut,\\n                swapOutputAmount,\\n                order.minOutputAmount()\\n            );\\n        } catch (bytes memory reasonBytes) {\\n            (string memory reason, /* bool hasRevertMessage */) = ErrorUtils.getRevertMessage(reasonBytes);\\n\\n            _handleSwapError(\\n                params.contracts.oracle,\\n                order,\\n                result,\\n                reason,\\n                reasonBytes\\n            );\\n        }\\n    }\\n```\\n\\n```\\n    null(\\n        Oracle oracle,\\n        Order.Props memory order,\\n        DecreasePositionUtils.DecreasePositionResult memory result,\\n        string memory reason,\\n        bytes memory reasonBytes\\n    ) internal {\\n        emit SwapUtils.SwapReverted(reason, reasonBytes);\\n\\n        _validateOutputAmount(\\n            oracle,\\n            result.outputToken,\\n            result.outputAmount,\\n            order.minOutputAmount()\\n        );\\n\\n        MarketToken(payable(order.market())).transferOut(\\n            result.outputToken,\\n            order.receiver(),\\n            result.outputAmount,\\n            order.shouldUnwrapNativeToken()\\n        );\\n    }\\n```\\n\\nAs you can see in this case `_validateOutputAmount` function will be called as well, but it will be called with `result.outputAmount` this time, which is amount provided by decreasing of position.\\nNow i will describe the problem. In case if user wants to swap his token, he knows that he needs to pay fees to the market pools and that this swap will eat some amount of output. So in case if `result.outputAmount` is 100$ worth of tokenA, it's fine if user will provide slippage as 3% if he has long swap path, so his slippage is 97$. But in case when swap will fail, then now this slippage of 97$ is incorrect as user didn't do swapping and he should receiev exactly 100$ worth of tokenA.\\nAlso i should note here, that it's easy to make swap fail for keeper, it's enough for him to just not provide any asset price, so swap reverts. So keeper can benefit on this slippage issue.
Issue User can loose funds in case if swapping in DecreaseOrderUtils.processOrder will fail\\nMaybe it's needed to have another slippage param, that should be used in case of no swapping.
User can be frontruned to receive less amount in case of swapping error.
```\\n        try params.contracts.swapHandler.swap(\\n            SwapUtils.SwapParams(\\n                params.contracts.dataStore,\\n                params.contracts.eventEmitter,\\n                params.contracts.oracle,\\n                Bank(payable(order.market())),\\n                params.key,\\n                result.outputToken,\\n                result.outputAmount,\\n                params.swapPathMarkets,\\n                0,\\n                order.receiver(),\\n                order.uiFeeReceiver(),\\n                order.shouldUnwrapNativeToken()\\n            )\\n        ) returns (address tokenOut, uint256 swapOutputAmount) {\\n            `(\\n                params.contracts.oracle,\\n                tokenOut,\\n                swapOutputAmount,\\n                order.minOutputAmount()\\n            );\\n        } catch (bytes memory reasonBytes) {\\n            (string memory reason, /* bool hasRevertMessage */) = ErrorUtils.getRevertMessage(reasonBytes);\\n\\n            _handleSwapError(\\n                params.contracts.oracle,\\n                order,\\n                result,\\n                reason,\\n                reasonBytes\\n            );\\n        }\\n    }\\n```\\n