private async Task <bool> ReserveFundsAsync(InternalOrder internalOrder)
        {
            Instrument instrument = await _instrumentService.TryGetByAssetPairIdAsync(internalOrder.AssetPairId);

            AssetPair assetPair = await _assetsServiceWithCache.TryGetAssetPairAsync(instrument.AssetPairId);

            string  assetId;
            decimal amount;

            if (internalOrder.Type == LimitOrderType.Sell)
            {
                assetId = assetPair.BaseAssetId;
                amount  = internalOrder.Volume;
            }
            else
            {
                Asset asset = await _assetsServiceWithCache.TryGetAssetAsync(assetPair.QuotingAssetId);

                assetId = assetPair.QuotingAssetId;
                amount  = (internalOrder.Volume * internalOrder.Price).TruncateDecimalPlaces(asset.Accuracy, true);
            }

            _log.InfoWithDetails("Reserve funds for internal trade",
                                 new { OrderId = internalOrder.Id, Asset = assetId, Amount = amount });

            string error = null;

            string walletId = await _settingsService.GetWalletIdAsync();

            try
            {
                await _lykkeExchangeService.TransferAsync(internalOrder.WalletId, walletId, assetId, amount);
            }
            catch (NotEnoughFundsException)
            {
                error = Errors.NotEnoughFunds;
            }
            catch (Exception)
            {
                error = "An unexpected error occurred during reserving funds";
            }

            if (!string.IsNullOrEmpty(error))
            {
                internalOrder.Status       = InternalOrderStatus.Rejected;
                internalOrder.RejectReason = error;

                await _internalOrderRepository.UpdateAsync(internalOrder);

                return(false);
            }

            internalOrder.Status = InternalOrderStatus.Reserved;
            await _internalOrderRepository.UpdateAsync(internalOrder);

            return(true);
        }