Merge pull request 'Fixed websocket' (#29) from Alex/stcs:devel into stable

Reviewed-on: #29

app/bybit/open_positions.py

@@ -54,12 +54,6 @@ async def start_trading_cycle(
             tg_id=tg_id,
             symbol=symbol,
             mode=0)
-        await set_margin_mode(tg_id=tg_id, margin_mode=margin_type)
-        await set_leverage(
-            tg_id=tg_id,
-            symbol=symbol,
-            leverage=leverage,
-        )
 
         await rq.set_user_deal(
             tg_id=tg_id,
@@ -316,7 +310,12 @@ async def open_positions(
     try:
         client = await get_bybit_client(tg_id=tg_id)
         get_ticker = await get_tickers(tg_id, symbol=symbol)
-        price_symbol = safe_float(get_ticker.get("lastPrice")) or 0
+
+        if get_ticker is None:
+            price_symbol = 0
+        else:
+            price_symbol = safe_float(get_ticker.get("lastPrice"))
+
         instruments_info = await get_instruments_info(tg_id=tg_id, symbol=symbol)
         qty_step_str = instruments_info.get("lotSizeFilter").get("qtyStep")
         qty_step = safe_float(qty_step_str)

app/bybit/set_functions/set_tp_sl.py

@@ -25,11 +25,13 @@ async def set_tp_sl_for_position(
     """
     try:
         client = await get_bybit_client(tg_id)
+        take_profit = round(take_profit_price, 6) if take_profit_price is not None else None
+        stop_loss = round(stop_loss_price, 6) if stop_loss_price is not None else None
         resp = client.set_trading_stop(
             category="linear",
             symbol=symbol,
-            takeProfit=str(round(take_profit_price, 5)),
+            takeProfit=str(take_profit) if take_profit is not None else None,
-            stopLoss=str(round(stop_loss_price, 5)),
+            stopLoss=str(stop_loss) if stop_loss is not None else None,
             positionIdx=position_idx,
             tpslMode="Full",
         )

app/bybit/telegram_message_handler.py

@@ -1,9 +1,10 @@
 import logging.config
 import math
-
+# import json
 import app.telegram.keyboards.inline as kbi
 import database.request as rq
 from app.bybit.get_functions.get_instruments_info import get_instruments_info
+from app.bybit.get_functions.get_positions import get_active_positions_by_symbol
 from app.bybit.logger_bybit.logger_bybit import LOGGING_CONFIG
 from app.bybit.open_positions import trading_cycle, trading_cycle_profit
 from app.bybit.set_functions.set_tp_sl import set_tp_sl_for_position
@@ -56,261 +57,289 @@ class TelegramMessageHandler:
 
     async def format_execution_update(self, message, tg_id):
         try:
+            # logger.info("Execution update: %s", json.dumps(message))
             execution = message.get("data", [{}])[0]
-            closed_size = format_value(execution.get("closedSize"))
+            exec_type = format_value(execution.get("execType"))
-            symbol = format_value(execution.get("symbol"))
+            if exec_type == "Trade" or exec_type == "BustTrade":
-            exec_price = format_value(execution.get("execPrice"))
+                closed_size = format_value(execution.get("closedSize"))
-            exec_qty = format_value(execution.get("execQty"))
+                symbol = format_value(execution.get("symbol"))
-            exec_fees = format_value(execution.get("execFee"))
+                exec_price = format_value(execution.get("execPrice"))
-            fee_rate = format_value(execution.get("feeRate"))
+                exec_qty = format_value(execution.get("execQty"))
-            side = format_value(execution.get("side"))
+                exec_fees = format_value(execution.get("execFee"))
+                fee_rate = format_value(execution.get("feeRate"))
+                side = format_value(execution.get("side"))
 
-            user_auto_trading = await rq.get_user_auto_trading(
+                user_auto_trading = await rq.get_user_auto_trading(
-                tg_id=tg_id, symbol=symbol
+                    tg_id=tg_id, symbol=symbol
-            )
-            auto_trading = (
-                user_auto_trading.auto_trading if user_auto_trading else False
-            )
-
-            side_rus = (
-                "Покупка"
-                if side == "Buy"
-                else "Продажа" if side == "Sell" else "Нет данных"
-            )
-            if safe_float(exec_fees) == 0:
-                exec_fee = safe_float(exec_price) * safe_float(exec_qty) * safe_float(
-                    fee_rate
                 )
-            else:
+                auto_trading = (
-                exec_fee = safe_float(exec_fees)
+                    user_auto_trading.auto_trading if user_auto_trading else False
-
-            if safe_float(closed_size) == 0:
-                await rq.set_fee_user_auto_trading(
-                    tg_id=tg_id, symbol=symbol, fee=safe_float(exec_fee)
                 )
 
-            get_total_fee = user_auto_trading.total_fee
+                side_rus = (
-            total_fee = safe_float(exec_fee) + safe_float(get_total_fee)
+                    "Покупка"
-
+                    if side == "Buy"
-            exec_pnl = format_value(execution.get("execPnl"))
+                    else "Продажа" if side == "Sell" else "Нет данных"
-            ex_pnl = safe_float(exec_pnl)
+                )
-            pnl = safe_float(exec_pnl)
+                if safe_float(exec_fees) == 0:
-
+                    exec_fee = safe_float(exec_price) * safe_float(exec_qty) * safe_float(
-            header = (
+                        fee_rate
-                "Сделка закрыта:" if safe_float(closed_size) > 0 else "Сделка открыта:"
+                    )
-            )
-            text = f"{header}\n" f"Торговая пара: {symbol}\n"
-            user_deals_data = await rq.get_user_deal_by_symbol(
-                tg_id=tg_id, symbol=symbol
-            )
-            commission_fee = user_deals_data.commission_fee or "Yes_commission_fee"
-            commission_place = user_deals_data.commission_place or "Commission_for_qty"
-            current_series = user_deals_data.current_series
-            current_step = user_deals_data.current_step
-            order_quantity = user_deals_data.order_quantity
-            pnl_series = user_deals_data.pnl_series
-            margin_type = user_deals_data.margin_type
-            take_profit_percent = user_deals_data.take_profit_percent
-            stop_loss_percent = user_deals_data.stop_loss_percent
-            fee = safe_float(user_auto_trading.fee)
-            total_pnl = safe_float(exec_pnl) - safe_float(exec_fee) - fee
-            leverage = safe_float(user_deals_data.leverage)
-
-            if commission_fee == "Yes_commission_fee":
-                if commission_place == "Commission_for_qty":
-                    total_quantity = safe_float(order_quantity) + safe_float(
-                        total_fee
-                    ) * 2
                 else:
-                    total_quantity = safe_float(order_quantity)
+                    exec_fee = safe_float(exec_fees)
-            else:
-                total_quantity = safe_float(order_quantity)
 
-            if user_deals_data is not None and auto_trading and safe_float(closed_size) == 0:
+                if safe_float(closed_size) == 0:
-                await rq.set_total_fee_user_auto_trading(
+                    await rq.set_fee_user_auto_trading(
-                    tg_id=tg_id, symbol=symbol, total_fee=total_fee
+                        tg_id=tg_id, symbol=symbol, fee=safe_float(exec_fee)
+                    )
+
+                get_total_fee = 0
+
+                if user_auto_trading is not None:
+                    get_total_fee = user_auto_trading.total_fee
+
+                total_fee = safe_float(exec_fee) + safe_float(get_total_fee)
+
+                exec_pnl = format_value(execution.get("execPnl"))
+                ex_pnl = safe_float(exec_pnl)
+                pnl = safe_float(exec_pnl)
+
+                header = (
+                    "Сделка закрыта:" if safe_float(closed_size) > 0 else "Сделка открыта:"
                 )
-                text += f"Текущая ставка: {total_quantity:.2f} USDT\n"
+                text = f"{header}\n" f"Торговая пара: {symbol}\n"
-                text += f"Серия №: {current_series}\n"
+                user_deals_data = await rq.get_user_deal_by_symbol(
-                text += f"Сделка №: {current_step}\n"
+                    tg_id=tg_id, symbol=symbol
+                )
+                if user_deals_data is None:
+                    commission_fee = "Yes_commission_fee"
+                    commission_place = "Commission_for_qty"
 
-            text += (
+                else:
-                f"Цена исполнения: {exec_price}\n"
+                    commission_fee = user_deals_data.commission_fee or "Yes_commission_fee"
-                f"Комиссия: {exec_fee:.8f}\n"
+                    commission_place = user_deals_data.commission_place or "Commission_for_qty"
-            )
 
-            if safe_float(closed_size) == 0:
+                current_series = user_deals_data.current_series
-                instruments_info = await get_instruments_info(tg_id=tg_id, symbol=symbol)
+                current_step = user_deals_data.current_step
-                qty_step_str = instruments_info.get("lotSizeFilter").get("qtyStep")
+                order_quantity = user_deals_data.order_quantity
-                qty_step = safe_float(qty_step_str)
+                pnl_series = user_deals_data.pnl_series
-                qty = (safe_float(order_quantity) * safe_float(leverage)) / safe_float(exec_price)
+                margin_type = user_deals_data.margin_type
-                decimals = abs(int(round(math.log10(qty_step))))
+                take_profit_percent = user_deals_data.take_profit_percent
-                qty_format = math.floor(qty / qty_step) * qty_step
+                stop_loss_percent = user_deals_data.stop_loss_percent
-                qty_formatted = round(qty_format, decimals)
+                fee = safe_float(user_auto_trading.fee)
-                total_commission = 0
+                total_pnl = safe_float(exec_pnl) - safe_float(exec_fee) - fee
+                leverage = safe_float(user_deals_data.leverage)
 
                 if commission_fee == "Yes_commission_fee":
-                    if commission_place == "Commission_for_tp":
+                    if commission_place == "Commission_for_qty":
-                        total_commission = safe_float(total_fee) / qty_formatted
+                        total_quantity = safe_float(order_quantity) + safe_float(
-
+                            total_fee
-                if margin_type == "ISOLATED_MARGIN":
+                        ) * 2
-                    if side == "Buy":
-                        take_profit_price = safe_float(exec_price) * (
-                                1 + take_profit_percent / 100) + total_commission
-                        stop_loss_price = None
                     else:
-                        take_profit_price = safe_float(exec_price) * (
+                        total_quantity = safe_float(order_quantity)
-                                1 - take_profit_percent / 100) - total_commission
-                        stop_loss_price = None
                 else:
-                    if side == "Buy":
+                    total_quantity = safe_float(order_quantity)
-                        take_profit_price = safe_float(exec_price) * (
-                                1 + take_profit_percent / 100) + total_commission
-                        stop_loss_price = safe_float(exec_price) * (1 - stop_loss_percent / 100)
-                    else:
-                        take_profit_price = safe_float(exec_price) * (
-                                1 - take_profit_percent / 100) - total_commission
-                        stop_loss_price = safe_float(exec_price) * (1 + stop_loss_percent / 100)
 
-                    take_profit_price = max(take_profit_price, 0)
+                if user_deals_data is not None and auto_trading and safe_float(closed_size) == 0:
-                    stop_loss_price = max(stop_loss_price, 0)
-
-                ress = await set_tp_sl_for_position(tg_id=tg_id,
-                                                    symbol=symbol,
-                                                    take_profit_price=take_profit_price,
-                                                    stop_loss_price=stop_loss_price,
-                                                    position_idx=0)
-                if ress:
-                    take_profit_truncated = await truncate_float(take_profit_price, 6)
-                    stop_loss_truncated = await truncate_float(stop_loss_price, 6)
-
-                    text += (f"Движение: {side_rus}\n"
-                             f"Тейк-профит: {take_profit_truncated}\n"
-                             f"Стоп-лосс: {stop_loss_truncated}\n"
-                             )
-                else:
-                    text += (f"Движение: {side_rus}\n"
-                             "Не удалось установить ТП и СЛ\n")
-
-            else:
-                if auto_trading:
-                    new_pnl = safe_float(pnl_series) + total_pnl
-                    await rq.set_pnl_series_by_symbol(
-                        tg_id=tg_id, symbol=symbol, pnl_series=new_pnl)
-                    text += f"\nПрибыль без комиссии: {ex_pnl:.4f}\n"
-                    text += f"Реализованная прибыль: {total_pnl:.4f}\n"
-                    text += f"Прибыль серии: {safe_float(new_pnl):.4f}\n"
-                else:
-                    text += f"\nПрибыль без комиссии: {ex_pnl:.4f}\n"
-                    text += f"Реализованная прибыль: {total_pnl:.4f}\n"
-
-            await self.telegram_bot.send_message(
-                chat_id=tg_id, text=text, reply_markup=kbi.profile_bybit
-            )
-
-            user_symbols = user_auto_trading.symbol if user_auto_trading else None
-
-            if (
-                    auto_trading
-                    and safe_float(closed_size) > 0
-                    and user_symbols is not None
-            ):
-                if safe_float(pnl) > 0:
-                    profit_text = "📈 Начинаю новую серию с базовой ставки\n"
-                    await self.telegram_bot.send_message(
-                        chat_id=tg_id, text=profit_text, reply_markup=kbi.profile_bybit
-                    )
-
-                    if side == "Buy":
-                        r_side = "Sell"
-                    else:
-                        r_side = "Buy"
-
-                    await rq.set_last_side_by_symbol(
-                        tg_id=tg_id, symbol=symbol, last_side=r_side)
                     await rq.set_total_fee_user_auto_trading(
-                        tg_id=tg_id, symbol=symbol, total_fee=0
+                        tg_id=tg_id, symbol=symbol, total_fee=total_fee
                     )
-                    await rq.set_fee_user_auto_trading(
+                    text += f"Текущая ставка: {total_quantity:.2f} USDT\n"
-                        tg_id=tg_id, symbol=symbol, fee=0
+                    text += f"Серия №: {current_series}\n"
-                    )
+                    text += f"Сделка №: {current_step}\n"
-                    await rq.set_pnl_series_by_symbol(tg_id=tg_id, symbol=symbol, pnl_series=0)
 
-                    res = await trading_cycle_profit(
+                text += (
-                        tg_id=tg_id, symbol=symbol, side=r_side
+                    f"Цена исполнения: {exec_price}\n"
-                    )
+                    f"Комиссия: {exec_fee:.8f}\n"
-                    if res == "OK":
+                )
-                        pass
+
+                if safe_float(closed_size) == 0:
+                    instruments_info = await get_instruments_info(tg_id=tg_id, symbol=symbol)
+                    qty_step_str = instruments_info.get("lotSizeFilter").get("qtyStep")
+                    qty_step = safe_float(qty_step_str)
+                    qty = (safe_float(order_quantity) * safe_float(leverage)) / safe_float(exec_price)
+                    decimals = abs(int(round(math.log10(qty_step))))
+                    qty_format = math.floor(qty / qty_step) * qty_step
+                    qty_formatted = round(qty_format, decimals)
+                    total_commission = 0
+
+                    if commission_fee == "Yes_commission_fee":
+                        if commission_place == "Commission_for_tp":
+                            total_commission = safe_float(total_fee) / qty_formatted
+
+                    if margin_type == "ISOLATED_MARGIN":
+                        if side == "Buy":
+                            take_profit_price = safe_float(exec_price) * (
+                                    1 + take_profit_percent / 100) + total_commission
+                            stop_loss_price = None
+                        else:
+                            take_profit_price = safe_float(exec_price) * (
+                                    1 - take_profit_percent / 100) - total_commission
+                            stop_loss_price = None
                     else:
-                        errors = {
+                        if side == "Buy":
-                            "Max bets in series": "❗️ Максимальное количество сделок в серии достигнуто",
+                            take_profit_price = safe_float(exec_price) * (
-                            "Risk is too high for this trade": "❗️ Риск сделки слишком высок для продолжения",
+                                    1 + take_profit_percent / 100) + total_commission
-                            "ab not enough for new order": "❗️ Недостаточно средств для продолжения торговли",
+                            stop_loss_price = safe_float(exec_price) * (1 - stop_loss_percent / 100)
-                            "InvalidRequestError": "❗️ Недостаточно средств для размещения нового ордера с заданным количеством и плечом.",
+                        else:
-                            "The number of contracts exceeds maximum limit allowed": "❗️ Превышен максимальный лимит ставки",
+                            take_profit_price = safe_float(exec_price) * (
-                            "Order placement failed as your position may exceed the max": "❗️ Превышен максимальный лимит ставки",
+                                    1 - take_profit_percent / 100) - total_commission
-                        }
+                            stop_loss_price = safe_float(exec_price) * (1 + stop_loss_percent / 100)
-                        error_text = errors.get(
+
-                            res, "❗️ Не удалось открыть новую сделку"
+                        take_profit_price = max(take_profit_price, 0)
-                        )
+                        stop_loss_price = max(stop_loss_price, 0)
-                        await rq.set_auto_trading(
+
-                            tg_id=tg_id, symbol=symbol, auto_trading=False
+                    ress = await set_tp_sl_for_position(tg_id=tg_id,
-                        )
+                                                        symbol=symbol,
+                                                        take_profit_price=take_profit_price,
+                                                        stop_loss_price=stop_loss_price,
+                                                        position_idx=0)
+                    if ress:
+                        take_profit_truncated = await truncate_float(take_profit_price, 6)
+                        text += (f"Движение: {side_rus}\n"
+                                 f"Тейк-профит: {take_profit_truncated}\n"
+                                 )
+                        if stop_loss_price is not None:
+                            stop_loss_truncated = await truncate_float(stop_loss_price, 6)
+                        else:
+                            stop_loss_truncated = None
+
+                        if stop_loss_truncated is not None:
+                            text += f"Стоп-лосс: {stop_loss_truncated}\n"
+                        else:
+                            deals = await get_active_positions_by_symbol(
+                                tg_id=tg_id, symbol=symbol
+                            )
+                            position = next((d for d in deals if d.get("symbol") == symbol), None)
+
+                            if position:
+                                liq_price = position.get("liqPrice", 0)
+                                text += f"Цена ликвидации: {liq_price}\n"
+
+
+                    else:
+                        text += (f"Движение: {side_rus}\n"
+                                 "Не удалось установить ТП и СЛ\n")
 
-                        await rq.set_total_fee_user_auto_trading(
-                            tg_id=tg_id, symbol=symbol, total_fee=0
-                        )
-                        await rq.set_fee_user_auto_trading(
-                            tg_id=tg_id, symbol=symbol, fee=0
-                        )
-                        await self.telegram_bot.send_message(
-                            chat_id=tg_id,
-                            text=error_text,
-                            reply_markup=kbi.profile_bybit,
-                        )
                 else:
-                    open_order_text = "\n❗️ Открываю новую сделку с увеличенной ставкой.\n"
+                    if auto_trading:
-                    await self.telegram_bot.send_message(
+                        new_pnl = safe_float(pnl_series) + total_pnl
-                        chat_id=tg_id, text=open_order_text
+                        await rq.set_pnl_series_by_symbol(
-                    )
+                            tg_id=tg_id, symbol=symbol, pnl_series=new_pnl)
-
+                        text += f"\nПрибыль без комиссии: {ex_pnl:.4f}\n"
-                    if side == "Buy":
+                        text += f"Реализованная прибыль: {total_pnl:.4f}\n"
-                        r_side = "Sell"
+                        text += f"Прибыль серии: {safe_float(new_pnl):.4f}\n"
                     else:
-                        r_side = "Buy"
+                        text += f"\nПрибыль без комиссии: {ex_pnl:.4f}\n"
+                        text += f"Реализованная прибыль: {total_pnl:.4f}\n"
 
-                    res = await trading_cycle(
+                await self.telegram_bot.send_message(
-                        tg_id=tg_id, symbol=symbol, side=r_side
+                    chat_id=tg_id, text=text, reply_markup=kbi.profile_bybit
-                    )
+                )
 
-                    if res == "OK":
+                user_symbols = user_auto_trading.symbol if user_auto_trading else None
-                        pass
+
-                    else:
+                if (
-                        errors = {
+                        auto_trading
-                            "Max bets in series": "❗️ Максимальное количество сделок в серии достигнуто",
+                        and safe_float(closed_size) > 0
-                            "Risk is too high for this trade": "❗️ Риск сделки слишком высок для продолжения",
+                        and user_symbols is not None
-                            "ab not enough for new order": "❗️ Недостаточно средств для продолжения торговли",
+                ):
-                            "InvalidRequestError": "❗️ Недостаточно средств для размещения нового ордера с заданным количеством и плечом.",
+                    if safe_float(pnl) > 0:
-                            "The number of contracts exceeds maximum limit allowed": "❗️ Превышен максимальный лимит ставки",
+                        profit_text = "📈 Начинаю новую серию с базовой ставки\n"
-                            "Order placement failed as your position may exceed the max": "❗️ Превышен максимальный лимит ставки",
+                        await self.telegram_bot.send_message(
-                        }
+                            chat_id=tg_id, text=profit_text, reply_markup=kbi.profile_bybit
-                        error_text = errors.get(
-                            res, "❗️ Не удалось открыть новую сделку"
-                        )
-                        await rq.set_auto_trading(
-                            tg_id=tg_id, symbol=symbol, auto_trading=False
                         )
 
+                        if side == "Buy":
+                            r_side = "Sell"
+                        else:
+                            r_side = "Buy"
+
+                        await rq.set_last_side_by_symbol(
+                            tg_id=tg_id, symbol=symbol, last_side=r_side)
                         await rq.set_total_fee_user_auto_trading(
                             tg_id=tg_id, symbol=symbol, total_fee=0
                         )
                         await rq.set_fee_user_auto_trading(
                             tg_id=tg_id, symbol=symbol, fee=0
                         )
-                        await self.telegram_bot.send_message(
+                        await rq.set_pnl_series_by_symbol(tg_id=tg_id, symbol=symbol, pnl_series=0)
-                            chat_id=tg_id,
+
-                            text=error_text,
+                        res = await trading_cycle_profit(
-                            reply_markup=kbi.profile_bybit,
+                            tg_id=tg_id, symbol=symbol, side=r_side
                         )
+                        if res == "OK":
+                            pass
+                        else:
+                            errors = {
+                                "Max bets in series": "❗️ Максимальное количество сделок в серии достигнуто",
+                                "Risk is too high for this trade": "❗️ Риск сделки слишком высок для продолжения",
+                                "ab not enough for new order": "❗️ Недостаточно средств для продолжения торговли",
+                                "InvalidRequestError": "❗️ Недостаточно средств для размещения нового ордера с заданным количеством и плечом.",
+                                "The number of contracts exceeds maximum limit allowed": "❗️ Превышен максимальный лимит ставки",
+                                "Order placement failed as your position may exceed the max": "❗️ Превышен максимальный лимит ставки",
+                            }
+                            error_text = errors.get(
+                                res, "❗️ Не удалось открыть новую сделку"
+                            )
+                            await rq.set_auto_trading(
+                                tg_id=tg_id, symbol=symbol, auto_trading=False
+                            )
+
+                            await rq.set_total_fee_user_auto_trading(
+                                tg_id=tg_id, symbol=symbol, total_fee=0
+                            )
+                            await rq.set_fee_user_auto_trading(
+                                tg_id=tg_id, symbol=symbol, fee=0
+                            )
+                            await self.telegram_bot.send_message(
+                                chat_id=tg_id,
+                                text=error_text,
+                                reply_markup=kbi.profile_bybit,
+                            )
+                    else:
+                        open_order_text = "\n❗️ Открываю новую сделку с увеличенной ставкой.\n"
+                        await self.telegram_bot.send_message(
+                            chat_id=tg_id, text=open_order_text
+                        )
+
+                        if side == "Buy":
+                            r_side = "Sell"
+                        else:
+                            r_side = "Buy"
+
+                        res = await trading_cycle(
+                            tg_id=tg_id, symbol=symbol, side=r_side
+                        )
+
+                        if res == "OK":
+                            pass
+                        else:
+                            errors = {
+                                "Max bets in series": "❗️ Максимальное количество сделок в серии достигнуто",
+                                "Risk is too high for this trade": "❗️ Риск сделки слишком высок для продолжения",
+                                "ab not enough for new order": "❗️ Недостаточно средств для продолжения торговли",
+                                "InvalidRequestError": "❗️ Недостаточно средств для размещения нового ордера с заданным количеством и плечом.",
+                                "The number of contracts exceeds maximum limit allowed": "❗️ Превышен максимальный лимит ставки",
+                                "Order placement failed as your position may exceed the max": "❗️ Превышен максимальный лимит ставки",
+                            }
+                            error_text = errors.get(
+                                res, "❗️ Не удалось открыть новую сделку"
+                            )
+                            await rq.set_auto_trading(
+                                tg_id=tg_id, symbol=symbol, auto_trading=False
+                            )
+
+                            await rq.set_total_fee_user_auto_trading(
+                                tg_id=tg_id, symbol=symbol, total_fee=0
+                            )
+                            await rq.set_fee_user_auto_trading(
+                                tg_id=tg_id, symbol=symbol, fee=0
+                            )
+                            await self.telegram_bot.send_message(
+                                chat_id=tg_id,
+                                text=error_text,
+                                reply_markup=kbi.profile_bybit,
+                            )
         except Exception as e:
             logger.error("Error in telegram_message_handler: %s", e, exc_info=True)

app/bybit/web_socket.py

@@ -25,7 +25,6 @@ class WebSocketBot:
         self.user_keys = {}
         self.loop = None
         self.message_handler = TelegramMessageHandler(telegram_bot)
-        self.last_execution_seq = {}
 
     async def run_user_check_loop(self):
         """Run a loop to check for users and connect them to the WebSocket."""
@@ -106,18 +105,8 @@ class WebSocketBot:
         await self.message_handler.format_order_update(message, tg_id)
 
     async def handle_execution_update(self, message, tg_id):
-        """Handle execution updates."""
+        """Handle execution updates without duplicate processing."""
-        data_items = message.get('data', [])
+        await self.message_handler.format_execution_update(message, tg_id)
-        if not data_items:
-            return
-        for exec_data in data_items:
-            seq = exec_data.get('seq')
-            if tg_id not in self.last_execution_seq:
-                self.last_execution_seq[tg_id] = -1
-            if seq <= self.last_execution_seq[tg_id]:
-                continue
-            self.last_execution_seq[tg_id] = seq
-            await self.message_handler.format_execution_update(message, tg_id)
 
     @staticmethod
     async def get_users_from_db():