ccxt 4.3.11__py2.py3-none-any.whl → 4.3.12__py2.py3-none-any.whl

ccxt/pro/bitget.py

@@ -658,54 +658,69 @@ class bitget(ccxt.async_support.bitget):
         #         "side": "buy",
         #         "tradeId": "1116461060594286593"
         #     }
+        # swap private
         #
-        # order with trade in it
-        #     {
-        #         accBaseVolume: '0.1',
-        #         baseVolume: '0.1',
-        #         cTime: '1709221342922',
-        #         clientOid: '1147122943507734528',
-        #         enterPointSource: 'API',
-        #         feeDetail: [Array],
-        #         fillFee: '-0.0049578',
-        #         fillFeeCoin: 'USDT',
-        #         fillNotionalUsd: '8.263',
-        #         fillPrice: '82.63',
-        #         fillTime: '1709221342986',
-        #         force: 'gtc',
-        #         instId: 'LTCUSDT',
-        #         leverage: '10',
-        #         marginCoin: 'USDT',
-        #         marginMode: 'crossed',
-        #         notionalUsd: '8.268',
-        #         orderId: '1147122943499345921',
-        #         orderType: 'market',
-        #         pnl: '0',
-        #         posMode: 'hedge_mode',
-        #         posSide: 'short',
-        #         price: '0',
-        #         priceAvg: '82.63',
-        #         reduceOnly: 'no',
-        #         side: 'sell',
-        #         size: '0.1',
-        #         status: 'filled',
-        #         tradeId: '1147122943772479563',
-        #         tradeScope: 'T',
-        #         tradeSide: 'open',
-        #         uTime: '1709221342986'
-        #     }
+        #            {
+        #               "orderId": "1169142761031114781",
+        #               "tradeId": "1169142761312637004",
+        #               "symbol": "LTCUSDT",
+        #               "orderType": "market",
+        #               "side": "buy",
+        #               "price": "80.87",
+        #               "baseVolume": "0.1",
+        #               "quoteVolume": "8.087",
+        #               "profit": "0",
+        #               "tradeSide": "open",
+        #               "posMode": "hedge_mode",
+        #               "tradeScope": "taker",
+        #               "feeDetail": [
+        #                  {
+        #                     "feeCoin": "USDT",
+        #                     "deduction": "no",
+        #                     "totalDeductionFee": "0",
+        #                     "totalFee": "-0.0048522"
+        #                  }
+        #               ],
+        #               "cTime": "1714471276596",
+        #               "uTime": "1714471276596"
+        #            }
+        # spot private
+        #        {
+        #           "orderId": "1169142457356959747",
+        #           "tradeId": "1169142457636958209",
+        #           "symbol": "LTCUSDT",
+        #           "orderType": "market",
+        #           "side": "buy",
+        #           "priceAvg": "81.069",
+        #           "size": "0.074",
+        #           "amount": "5.999106",
+        #           "tradeScope": "taker",
+        #           "feeDetail": [
+        #              {
+        #                 "feeCoin": "LTC",
+        #                 "deduction": "no",
+        #                 "totalDeductionFee": "0",
+        #                 "totalFee": "0.000074"
+        #              }
+        #           ],
+        #           "cTime": "1714471204194",
+        #           "uTime": "1714471204194"
+        #        }
         #
-        instId = self.safe_string(trade, 'instId')
+        instId = self.safe_string_2(trade, 'symbol', 'instId')
+        posMode = self.safe_string(trade, 'posMode')
+        defaultType = 'contract' if (posMode is not None) else 'spot'
         if market is None:
-            market = self.safe_market(instId, None, None, 'contract')
+            market = self.safe_market(instId, None, None, defaultType)
         timestamp = self.safe_integer_n(trade, ['uTime', 'cTime', 'ts'])
-        feeCost = self.safe_string(trade, 'fillFee')
+        feeDetail = self.safe_list(trade, 'feeDetail', [])
+        first = self.safe_dict(feeDetail, 0)
         fee = None
-        if feeCost is not None:
-            feeCurrencyId = self.safe_string(trade, 'fillFeeCoin')
+        if first is not None:
+            feeCurrencyId = self.safe_string(first, 'feeCoin')
             feeCurrencyCode = self.safe_currency_code(feeCurrencyId)
             fee = {
-                'cost': Precise.string_abs(feeCost),
+                'cost': Precise.string_abs(self.safe_string(first, 'totalFee')),
                 'currency': feeCurrencyCode,
             }
         return self.safe_trade({
@@ -715,12 +730,12 @@ class bitget(ccxt.async_support.bitget):
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'symbol': market['symbol'],
-            'type': None,
+            'type': self.safe_string(trade, 'orderType'),
             'side': self.safe_string(trade, 'side'),
-            'takerOrMaker': None,
+            'takerOrMaker': self.safe_string(trade, 'tradeScope'),
             'price': self.safe_string_2(trade, 'priceAvg', 'price'),
-            'amount': self.safe_string(trade, 'size'),
-            'cost': self.safe_string(trade, 'fillNotionalUsd'),
+            'amount': self.safe_string_2(trade, 'size', 'baseVolume'),
+            'cost': self.safe_string_2(trade, 'amount', 'quoteVolume'),
             'fee': fee,
         }, market)
 
@@ -1100,8 +1115,6 @@ class bitget(ccxt.async_support.bitget):
         marketSymbols = {}
         for i in range(0, len(data)):
             order = data[i]
-            if 'tradeId' in order:
-                self.handle_my_trades(client, order)
             marketId = self.safe_string(order, 'instId')
             market = self.safe_market(marketId, None, None, marketType)
             parsed = self.parse_ws_order(order, market)
@@ -1293,8 +1306,6 @@ class bitget(ccxt.async_support.bitget):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
-        # only contracts stream provides the trade info consistently in between order updates
-        # the spot stream only provides on limit orders updates so we can't support it for spot
         await self.load_markets()
         market = None
         messageHash = 'myTrades'
@@ -1302,16 +1313,12 @@ class bitget(ccxt.async_support.bitget):
             market = self.market(symbol)
             symbol = market['symbol']
             messageHash = messageHash + ':' + symbol
-        type = None
-        type, params = self.handle_market_type_and_params('watchMyTrades', market, params)
-        if type == 'spot':
-            raise NotSupported(self.id + ' watchMyTrades is not supported for ' + type + ' markets.')
         instType = None
         instType, params = self.get_inst_type(market, params)
-        subscriptionHash = 'order:trades'
+        subscriptionHash = 'fill:' + instType
         args = {
             'instType': instType,
-            'channel': 'orders',
+            'channel': 'fill',
             'instId': 'default',
         }
         trades = await self.watch_private(messageHash, subscriptionHash, args, params)
@@ -1321,47 +1328,91 @@ class bitget(ccxt.async_support.bitget):
 
     def handle_my_trades(self, client: Client, message):
         #
-        # order and trade mixin(contract)
-        #
+        # spot
+        # {
+        #     "action": "snapshot",
+        #     "arg": {
+        #        "instType": "SPOT",
+        #        "channel": "fill",
+        #        "instId": "default"
+        #     },
+        #     "data": [
+        #        {
+        #           "orderId": "1169142457356959747",
+        #           "tradeId": "1169142457636958209",
+        #           "symbol": "LTCUSDT",
+        #           "orderType": "market",
+        #           "side": "buy",
+        #           "priceAvg": "81.069",
+        #           "size": "0.074",
+        #           "amount": "5.999106",
+        #           "tradeScope": "taker",
+        #           "feeDetail": [
+        #              {
+        #                 "feeCoin": "LTC",
+        #                 "deduction": "no",
+        #                 "totalDeductionFee": "0",
+        #                 "totalFee": "0.000074"
+        #              }
+        #           ],
+        #           "cTime": "1714471204194",
+        #           "uTime": "1714471204194"
+        #        }
+        #     ],
+        #     "ts": 1714471204270
+        # }
+        # swap
         #     {
-        #         "accBaseVolume": "0",
-        #         "cTime": "1701920553759",
-        #         "clientOid": "1116501214318198793",
-        #         "enterPointSource": "WEB",
-        #         "feeDetail": [{
-        #             "feeCoin": "USDT",
-        #             "fee": "-0.162003"
-        #         }],
-        #         "force": "gtc",
-        #         "instId": "BTCUSDT",
-        #         "leverage": "20",
-        #         "marginCoin": "USDT",
-        #         "marginMode": "isolated",
-        #         "notionalUsd": "105",
-        #         "orderId": "1116501214293032964",
-        #         "orderType": "limit",
-        #         "posMode": "hedge_mode",
-        #         "posSide": "long",
-        #         "price": "35000",
-        #         "reduceOnly": "no",
-        #         "side": "buy",
-        #         "size": "0.003",
-        #         "status": "canceled",
-        #         "tradeSide": "open",
-        #         "uTime": "1701920595866"
+        #         "action": "snapshot",
+        #         "arg": {
+        #            "instType": "USDT-FUTURES",
+        #            "channel": "fill",
+        #            "instId": "default"
+        #         },
+        #         "data": [
+        #            {
+        #               "orderId": "1169142761031114781",
+        #               "tradeId": "1169142761312637004",
+        #               "symbol": "LTCUSDT",
+        #               "orderType": "market",
+        #               "side": "buy",
+        #               "price": "80.87",
+        #               "baseVolume": "0.1",
+        #               "quoteVolume": "8.087",
+        #               "profit": "0",
+        #               "tradeSide": "open",
+        #               "posMode": "hedge_mode",
+        #               "tradeScope": "taker",
+        #               "feeDetail": [
+        #                  {
+        #                     "feeCoin": "USDT",
+        #                     "deduction": "no",
+        #                     "totalDeductionFee": "0",
+        #                     "totalFee": "-0.0048522"
+        #                  }
+        #               ],
+        #               "cTime": "1714471276596",
+        #               "uTime": "1714471276596"
+        #            }
+        #         ],
+        #         "ts": 1714471276629
         #     }
         #
         if self.myTrades is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             self.myTrades = ArrayCache(limit)
         stored = self.myTrades
-        parsed = self.parse_ws_trade(message)
-        stored.append(parsed)
-        symbol = parsed['symbol']
+        data = self.safe_list(message, 'data', [])
+        length = len(data)
         messageHash = 'myTrades'
+        for i in range(0, length):
+            trade = data[i]
+            parsed = self.parse_ws_trade(trade)
+            stored.append(parsed)
+            symbol = parsed['symbol']
+            symbolSpecificMessageHash = 'myTrades:' + symbol
+            client.resolve(stored, symbolSpecificMessageHash)
         client.resolve(stored, messageHash)
-        symbolSpecificMessageHash = 'myTrades:' + symbol
-        client.resolve(stored, symbolSpecificMessageHash)
 
     async def watch_balance(self, params={}) -> Balances:
         """
@@ -1623,6 +1674,7 @@ class bitget(ccxt.async_support.bitget):
         methods = {
             'ticker': self.handle_ticker,
             'trade': self.handle_trades,
+            'fill': self.handle_my_trades,
             'orders': self.handle_order,
             'ordersAlgo': self.handle_order,
             'account': self.handle_balance,

ccxt/pro/bybit.py

@@ -7,7 +7,7 @@ import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
 import asyncio
 import hashlib
-from ccxt.base.types import Balances, Int, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -22,7 +22,7 @@ class bybit(ccxt.async_support.bybit):
         return self.deep_extend(super(bybit, self).describe(), {
             'has': {
                 'ws': True,
-                'createOrderWs': False,
+                'createOrderWs': False,  # available only in sandbox
                 'editOrderWs': False,
                 'fetchOpenOrdersWs': False,
                 'fetchOrderWs': False,
@@ -60,6 +60,7 @@ class bybit(ccxt.async_support.bybit):
                             },
                             'contract': 'wss://stream.{hostname}/v5/private',
                             'usdc': 'wss://stream.{hostname}/trade/option/usdc/private/v1',
+                            'trade': 'wss://stream-testnet.bybit.com/v5/trade',
                         },
                     },
                 },
@@ -78,6 +79,7 @@ class bybit(ccxt.async_support.bybit):
                             },
                             'contract': 'wss://stream-testnet.{hostname}/v5/private',
                             'usdc': 'wss://stream-testnet.{hostname}/trade/option/usdc/private/v1',
+                            'trade': 'wss://stream-testnet.bybit.com/v5/trade',
                         },
                     },
                 },
@@ -172,6 +174,127 @@ class bybit(ccxt.async_support.bybit):
         params = self.omit(params, ['type', 'subType', 'settle', 'defaultSettle', 'unifiedMargin'])
         return params
 
+    async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
+        """
+        create a trade order
+        :see: https://bybit-exchange.github.io/docs/v5/order/create-order
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/trade/guideline#createamendcancel-order
+        :param str symbol: unified symbol of the market to create an order in
+        :param str type: 'market' or 'limit'
+        :param str side: 'buy' or 'sell'
+        :param float amount: how much of currency you want to trade in units of base currency
+        :param float [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.timeInForce]: "GTC", "IOC", "FOK"
+        :param bool [params.postOnly]: True or False whether the order is post-only
+        :param bool [params.reduceOnly]: True or False whether the order is reduce-only
+        :param str [params.positionIdx]: *contracts only*  0 for one-way mode, 1 buy side  of hedged mode, 2 sell side of hedged mode
+        :param boolean [params.isLeverage]: *unified spot only* False then spot trading True then margin trading
+        :param str [params.tpslMode]: *contract only* 'full' or 'partial'
+        :param str [params.mmp]: *option only* market maker protection
+        :param str [params.triggerDirection]: *contract only* the direction for trigger orders, 'above' or 'below'
+        :param float [params.triggerPrice]: The price at which a trigger order is triggered at
+        :param float [params.stopLossPrice]: The price at which a stop loss order is triggered at
+        :param float [params.takeProfitPrice]: The price at which a take profit order is triggered at
+        :param dict [params.takeProfit]: *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered
+        :param float [params.takeProfit.triggerPrice]: take profit trigger price
+        :param dict [params.stopLoss]: *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered
+        :param float [params.stopLoss.triggerPrice]: stop loss trigger price
+        :param str [params.trailingAmount]: the quote amount to trail away from the current market price
+        :param str [params.trailingTriggerPrice]: the price to trigger a trailing order, default uses the price argument
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        orderRequest = self.create_order_request(symbol, type, side, amount, price, params, True)
+        url = self.urls['api']['ws']['private']['trade']
+        await self.authenticate(url)
+        requestId = str(self.request_id())
+        request = {
+            'op': 'order.create',
+            'reqId': requestId,
+            'args': [
+                orderRequest,
+            ],
+            'header': {
+                'X-BAPI-TIMESTAMP': str(self.milliseconds()),
+                'X-BAPI-RECV-WINDOW': str(self.options['recvWindow']),
+            },
+        }
+        return await self.watch(url, requestId, request, requestId, True)
+
+    async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}):
+        """
+        edit a trade order
+        :see: https://bybit-exchange.github.io/docs/v5/order/amend-order
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/trade/guideline#createamendcancel-order
+        :param str id: cancel order id
+        :param str symbol: unified symbol of the market to create an order in
+        :param str type: 'market' or 'limit'
+        :param str side: 'buy' or 'sell'
+        :param float amount: how much of currency you want to trade in units of base currency
+        :param float price: the price at which the order is to be fullfilled, in units of the base currency, ignored in market orders
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param float [params.triggerPrice]: The price that a trigger order is triggered at
+        :param float [params.stopLossPrice]: The price that a stop loss order is triggered at
+        :param float [params.takeProfitPrice]: The price that a take profit order is triggered at
+        :param dict [params.takeProfit]: *takeProfit object in params* containing the triggerPrice that the attached take profit order will be triggered
+        :param float [params.takeProfit.triggerPrice]: take profit trigger price
+        :param dict [params.stopLoss]: *stopLoss object in params* containing the triggerPrice that the attached stop loss order will be triggered
+        :param float [params.stopLoss.triggerPrice]: stop loss trigger price
+        :param str [params.triggerBy]: 'IndexPrice', 'MarkPrice' or 'LastPrice', default is 'LastPrice', required if no initial value for triggerPrice
+        :param str [params.slTriggerBy]: 'IndexPrice', 'MarkPrice' or 'LastPrice', default is 'LastPrice', required if no initial value for stopLoss
+        :param str [params.tpTriggerby]: 'IndexPrice', 'MarkPrice' or 'LastPrice', default is 'LastPrice', required if no initial value for takeProfit
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        orderRequest = self.edit_order_request(id, symbol, type, side, amount, price, params)
+        url = self.urls['api']['ws']['private']['trade']
+        await self.authenticate(url)
+        requestId = str(self.request_id())
+        request = {
+            'op': 'order.amend',
+            'reqId': requestId,
+            'args': [
+                orderRequest,
+            ],
+            'header': {
+                'X-BAPI-TIMESTAMP': str(self.milliseconds()),
+                'X-BAPI-RECV-WINDOW': str(self.options['recvWindow']),
+            },
+        }
+        return await self.watch(url, requestId, request, requestId, True)
+
+    async def cancel_order_ws(self, id: str, symbol: Str = None, params={}):
+        """
+        cancels an open order
+        :see: https://bybit-exchange.github.io/docs/v5/order/cancel-order
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/trade/guideline#createamendcancel-order
+        :param str id: order id
+        :param str symbol: unified symbol of the market the order was made in
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.stop]: *spot only* whether the order is a stop order
+        :param str [params.orderFilter]: *spot only* 'Order' or 'StopOrder' or 'tpslOrder'
+        :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        orderRequest = self.cancelOrderRequest(id, symbol, params)
+        url = self.urls['api']['ws']['private']['trade']
+        await self.authenticate(url)
+        requestId = str(self.request_id())
+        del orderRequest['orderFilter']
+        request = {
+            'op': 'order.cancel',
+            'reqId': requestId,
+            'args': [
+                orderRequest,
+            ],
+            'header': {
+                'X-BAPI-TIMESTAMP': str(self.milliseconds()),
+                'X-BAPI-RECV-WINDOW': str(self.options['recvWindow']),
+            },
+        }
+        return await self.watch(url, requestId, request, requestId, True)
+
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
@@ -1029,6 +1152,32 @@ class bybit(ccxt.async_support.bybit):
             limit = orders.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(orders, symbol, since, limit, True)
 
+    def handle_order_ws(self, client: Client, message):
+        #
+        #    {
+        #        "reqId":"1",
+        #        "retCode":0,
+        #        "retMsg":"OK",
+        #        "op":"order.create",
+        #        "data":{
+        #            "orderId":"1673523595617593600",
+        #            "orderLinkId":"1673523595617593601"
+        #        },
+        #        "header":{
+        #            "X-Bapi-Limit":"20",
+        #            "X-Bapi-Limit-Status":"19",
+        #            "X-Bapi-Limit-Reset-Timestamp":"1714235558880",
+        #            "Traceid":"584a06d373f2fdcb3a4dfdd81d27df11",
+        #            "Timenow":"1714235558881"
+        #        },
+        #        "connId":"cojidqec0hv9fgvhtbt0-40e"
+        #    }
+        #
+        messageHash = self.safe_string(message, 'reqId')
+        data = self.safe_dict(message, 'data')
+        order = self.parse_order(data)
+        client.resolve(order, messageHash)
+
     def handle_order(self, client: Client, message):
         #
         #     spot
@@ -1599,11 +1748,32 @@ class bybit(ccxt.async_support.bybit):
         #
         #   {code: '-10009', desc: "Invalid period!"}
         #
-        code = self.safe_string_2(message, 'code', 'ret_code')
+        #   {
+        #       "reqId":"1",
+        #       "retCode":170131,
+        #       "retMsg":"Insufficient balance.",
+        #       "op":"order.create",
+        #       "data":{
+        #
+        #       },
+        #       "header":{
+        #           "X-Bapi-Limit":"20",
+        #           "X-Bapi-Limit-Status":"19",
+        #           "X-Bapi-Limit-Reset-Timestamp":"1714236608944",
+        #           "Traceid":"3d7168a137bf32a947b7e5e6a575ac7f",
+        #           "Timenow":"1714236608946"
+        #       },
+        #       "connId":"cojifin88smerbj9t560-406"
+        #   }
+        #
+        code = self.safe_string_n(message, ['code', 'ret_code', 'retCode'])
         try:
-            if code is not None:
+            if code is not None and code != '0':
                 feedback = self.id + ' ' + self.json(message)
                 self.throw_exactly_matched_exception(self.exceptions['exact'], code, feedback)
+                msg = self.safe_string_2(message, 'retMsg', 'ret_msg')
+                self.throw_broadly_matched_exception(self.exceptions['broad'], msg, feedback)
+                raise ExchangeError(feedback)
             success = self.safe_value(message, 'success')
             if success is not None and not success:
                 ret_msg = self.safe_string(message, 'ret_msg')
@@ -1621,7 +1791,8 @@ class bybit(ccxt.async_support.bybit):
                 if messageHash in client.subscriptions:
                     del client.subscriptions[messageHash]
             else:
-                client.reject(error)
+                messageHash = self.safe_string(message, 'reqId')
+                client.reject(error, messageHash)
             return True
 
     def handle_message(self, client: Client, message):
@@ -1638,15 +1809,11 @@ class bybit(ccxt.async_support.bybit):
             self.handle_pong(client, message)
             return
         # pong
-        op = self.safe_string(message, 'op')
-        if op == 'pong':
-            self.handle_pong(client, message)
-            return
         event = self.safe_string(message, 'event')
         if event == 'sub':
             self.handle_subscription_status(client, message)
             return
-        topic = self.safe_string(message, 'topic', '')
+        topic = self.safe_string_2(message, 'topic', 'op')
         methods = {
             'orderbook': self.handle_order_book,
             'kline': self.handle_ohlcv,
@@ -1662,6 +1829,11 @@ class bybit(ccxt.async_support.bybit):
             'ticketInfo': self.handle_my_trades,
             'user.openapi.perp.trade': self.handle_my_trades,
             'position': self.handle_positions,
+            'pong': self.handle_pong,
+            'order.create': self.handle_order_ws,
+            'order.amend': self.handle_order_ws,
+            'order.cancel': self.handle_order_ws,
+            'auth': self.handle_authenticate,
         }
         exacMethod = self.safe_value(methods, topic)
         if exacMethod is not None:
@@ -1676,7 +1848,7 @@ class bybit(ccxt.async_support.bybit):
                 return
         # unified auth acknowledgement
         type = self.safe_string(message, 'type')
-        if (op == 'auth') or (type == 'AUTH_RESP'):
+        if type == 'AUTH_RESP':
             self.handle_authenticate(client, message)
 
     def ping(self, client):
@@ -1708,9 +1880,17 @@ class bybit(ccxt.async_support.bybit):
         #        "conn_id": "ce3dpomvha7dha97tvp0-2xh"
         #    }
         #
+        #    {
+        #        "retCode":0,
+        #        "retMsg":"OK",
+        #        "op":"auth",
+        #        "connId":"cojifin88smerbj9t560-404"
+        #    }
+        #
         success = self.safe_value(message, 'success')
+        code = self.safe_integer(message, 'retCode')
         messageHash = 'authenticated'
-        if success:
+        if success or code == 0:
             future = self.safe_value(client.futures, messageHash)
             future.resolve(True)
         else: