ccxt 4.3.11 → 4.3.13

package/js/src/pro/bitget.js

@@ -694,55 +694,70 @@ export default class bitget extends bitgetRest {
         //         "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"
+        //        }
         //
-        const instId = this.safeString(trade, 'instId');
+        const instId = this.safeString2(trade, 'symbol', 'instId');
+        const posMode = this.safeString(trade, 'posMode');
+        const defaultType = (posMode !== undefined) ? 'contract' : 'spot';
         if (market === undefined) {
-            market = this.safeMarket(instId, undefined, undefined, 'contract');
+            market = this.safeMarket(instId, undefined, undefined, defaultType);
         }
         const timestamp = this.safeIntegerN(trade, ['uTime', 'cTime', 'ts']);
-        const feeCost = this.safeString(trade, 'fillFee');
+        const feeDetail = this.safeList(trade, 'feeDetail', []);
+        const first = this.safeDict(feeDetail, 0);
         let fee = undefined;
-        if (feeCost !== undefined) {
-            const feeCurrencyId = this.safeString(trade, 'fillFeeCoin');
+        if (first !== undefined) {
+            const feeCurrencyId = this.safeString(first, 'feeCoin');
             const feeCurrencyCode = this.safeCurrencyCode(feeCurrencyId);
             fee = {
-                'cost': Precise.stringAbs(feeCost),
+                'cost': Precise.stringAbs(this.safeString(first, 'totalFee')),
                 'currency': feeCurrencyCode,
             };
         }
@@ -753,12 +768,12 @@ export default class bitget extends bitgetRest {
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
             'symbol': market['symbol'],
-            'type': undefined,
+            'type': this.safeString(trade, 'orderType'),
             'side': this.safeString(trade, 'side'),
-            'takerOrMaker': undefined,
+            'takerOrMaker': this.safeString(trade, 'tradeScope'),
             'price': this.safeString2(trade, 'priceAvg', 'price'),
-            'amount': this.safeString(trade, 'size'),
-            'cost': this.safeString(trade, 'fillNotionalUsd'),
+            'amount': this.safeString2(trade, 'size', 'baseVolume'),
+            'cost': this.safeString2(trade, 'amount', 'quoteVolume'),
             'fee': fee,
         }, market);
     }
@@ -1164,9 +1179,6 @@ export default class bitget extends bitgetRest {
         const marketSymbols = {};
         for (let i = 0; i < data.length; i++) {
             const order = data[i];
-            if ('tradeId' in order) {
-                this.handleMyTrades(client, order);
-            }
             const marketId = this.safeString(order, 'instId');
             const market = this.safeMarket(marketId, undefined, undefined, marketType);
             const parsed = this.parseWsOrder(order, market);
@@ -1366,8 +1378,6 @@ export default class bitget extends bitgetRest {
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object[]} a list of [trade structures]{@link 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 this.loadMarkets();
         let market = undefined;
         let messageHash = 'myTrades';
@@ -1376,17 +1386,12 @@ export default class bitget extends bitgetRest {
             symbol = market['symbol'];
             messageHash = messageHash + ':' + symbol;
         }
-        let type = undefined;
-        [type, params] = this.handleMarketTypeAndParams('watchMyTrades', market, params);
-        if (type === 'spot') {
-            throw new NotSupported(this.id + ' watchMyTrades is not supported for ' + type + ' markets.');
-        }
         let instType = undefined;
         [instType, params] = this.getInstType(market, params);
-        const subscriptionHash = 'order:trades';
+        const subscriptionHash = 'fill:' + instType;
         const args = {
             'instType': instType,
-            'channel': 'orders',
+            'channel': 'fill',
             'instId': 'default',
         };
         const trades = await this.watchPrivate(messageHash, subscriptionHash, args, params);
@@ -1397,34 +1402,74 @@ export default class bitget extends bitgetRest {
     }
     handleMyTrades(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 (this.myTrades === undefined) {
@@ -1432,13 +1477,18 @@ export default class bitget extends bitgetRest {
             this.myTrades = new ArrayCache(limit);
         }
         const stored = this.myTrades;
-        const parsed = this.parseWsTrade(message);
-        stored.append(parsed);
-        const symbol = parsed['symbol'];
+        const data = this.safeList(message, 'data', []);
+        const length = data.length;
         const messageHash = 'myTrades';
+        for (let i = 0; i < length; i++) {
+            const trade = data[i];
+            const parsed = this.parseWsTrade(trade);
+            stored.append(parsed);
+            const symbol = parsed['symbol'];
+            const symbolSpecificMessageHash = 'myTrades:' + symbol;
+            client.resolve(stored, symbolSpecificMessageHash);
+        }
         client.resolve(stored, messageHash);
-        const symbolSpecificMessageHash = 'myTrades:' + symbol;
-        client.resolve(stored, symbolSpecificMessageHash);
     }
     async watchBalance(params = {}) {
         /**
@@ -1721,6 +1771,7 @@ export default class bitget extends bitgetRest {
         const methods = {
             'ticker': this.handleTicker,
             'trade': this.handleTrades,
+            'fill': this.handleMyTrades,
             'orders': this.handleOrder,
             'ordersAlgo': this.handleOrder,
             'account': this.handleBalance,

package/js/src/pro/bybit.d.ts

@@ -1,11 +1,14 @@
 import bybitRest from '../bybit.js';
-import type { Int, OHLCV, Str, Strings, Ticker, OrderBook, Order, Trade, Tickers, Position, Balances } from '../base/types.js';
+import type { Int, OHLCV, Str, Strings, Ticker, OrderBook, Order, Trade, Tickers, Position, Balances, OrderType, OrderSide, Num } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class bybit extends bybitRest {
     describe(): any;
     requestId(): any;
     getUrlByMarketType(symbol?: Str, isPrivate?: boolean, method?: Str, params?: {}): any;
     cleanParams(params: any): any;
+    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
+    editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;
+    cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTicker(client: Client, message: any): void;
@@ -29,6 +32,7 @@ export default class bybit extends bybitRest {
     loadPositionsSnapshot(client: any, messageHash: any): Promise<void>;
     handlePositions(client: any, message: any): void;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    handleOrderWs(client: Client, message: any): void;
     handleOrder(client: Client, message: any): void;
     parseWsSpotOrder(order: any, market?: any): Order;
     watchBalance(params?: {}): Promise<Balances>;

package/js/src/pro/bybit.js

@@ -53,6 +53,7 @@ export default class bybit extends bybitRest {
                             },
                             'contract': 'wss://stream.{hostname}/v5/private',
                             'usdc': 'wss://stream.{hostname}/trade/option/usdc/private/v1',
+                            'trade': 'wss://stream-testnet.bybit.com/v5/trade',
                         },
                     },
                 },
@@ -71,6 +72,7 @@ export default class bybit extends bybitRest {
                             },
                             '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,133 @@ export default class bybit extends bybitRest {
         params = this.omit(params, ['type', 'subType', 'settle', 'defaultSettle', 'unifiedMargin']);
         return params;
     }
+    async createOrderWs(symbol, type, side, amount, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name bybit#createOrderWs
+         * @description 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 {string} symbol unified symbol of the market to create an order in
+         * @param {string} type 'market' or 'limit'
+         * @param {string} 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 {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [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 {string} [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 {string} [params.tpslMode] *contract only* 'full' or 'partial'
+         * @param {string} [params.mmp] *option only* market maker protection
+         * @param {string} [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 {object} [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 {object} [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 {string} [params.trailingAmount] the quote amount to trail away from the current market price
+         * @param {string} [params.trailingTriggerPrice] the price to trigger a trailing order, default uses the price argument
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const orderRequest = this.createOrderRequest(symbol, type, side, amount, price, params, true);
+        const url = this.urls['api']['ws']['private']['trade'];
+        await this.authenticate(url);
+        const requestId = this.requestId().toString();
+        const request = {
+            'op': 'order.create',
+            'reqId': requestId,
+            'args': [
+                orderRequest,
+            ],
+            'header': {
+                'X-BAPI-TIMESTAMP': this.milliseconds().toString(),
+                'X-BAPI-RECV-WINDOW': this.options['recvWindow'].toString(),
+            },
+        };
+        return await this.watch(url, requestId, request, requestId, true);
+    }
+    async editOrderWs(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name bybit#editOrderWs
+         * @description 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 {string} id cancel order id
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {string} type 'market' or 'limit'
+         * @param {string} 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 {object} [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 {object} [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 {object} [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 {string} [params.triggerBy] 'IndexPrice', 'MarkPrice' or 'LastPrice', default is 'LastPrice', required if no initial value for triggerPrice
+         * @param {string} [params.slTriggerBy] 'IndexPrice', 'MarkPrice' or 'LastPrice', default is 'LastPrice', required if no initial value for stopLoss
+         * @param {string} [params.tpTriggerby] 'IndexPrice', 'MarkPrice' or 'LastPrice', default is 'LastPrice', required if no initial value for takeProfit
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const orderRequest = this.editOrderRequest(id, symbol, type, side, amount, price, params);
+        const url = this.urls['api']['ws']['private']['trade'];
+        await this.authenticate(url);
+        const requestId = this.requestId().toString();
+        const request = {
+            'op': 'order.amend',
+            'reqId': requestId,
+            'args': [
+                orderRequest,
+            ],
+            'header': {
+                'X-BAPI-TIMESTAMP': this.milliseconds().toString(),
+                'X-BAPI-RECV-WINDOW': this.options['recvWindow'].toString(),
+            },
+        };
+        return await this.watch(url, requestId, request, requestId, true);
+    }
+    async cancelOrderWs(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name bybit#cancelOrderWs
+         * @description 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 {string} id order id
+         * @param {string} symbol unified symbol of the market the order was made in
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.stop] *spot only* whether the order is a stop order
+         * @param {string} [params.orderFilter] *spot only* 'Order' or 'StopOrder' or 'tpslOrder'
+         * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const orderRequest = this.cancelOrderRequest(id, symbol, params);
+        const url = this.urls['api']['ws']['private']['trade'];
+        await this.authenticate(url);
+        const requestId = this.requestId().toString();
+        delete orderRequest['orderFilter'];
+        const request = {
+            'op': 'order.cancel',
+            'reqId': requestId,
+            'args': [
+                orderRequest,
+            ],
+            'header': {
+                'X-BAPI-TIMESTAMP': this.milliseconds().toString(),
+                'X-BAPI-RECV-WINDOW': this.options['recvWindow'].toString(),
+            },
+        };
+        return await this.watch(url, requestId, request, requestId, true);
+    }
     async watchTicker(symbol, params = {}) {
         /**
          * @method
@@ -1104,6 +1233,32 @@ export default class bybit extends bybitRest {
         }
         return this.filterBySymbolSinceLimit(orders, symbol, since, limit, true);
     }
+    handleOrderWs(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"
+        //    }
+        //
+        const messageHash = this.safeString(message, 'reqId');
+        const data = this.safeDict(message, 'data');
+        const order = this.parseOrder(data);
+        client.resolve(order, messageHash);
+    }
     handleOrder(client, message) {
         //
         //     spot
@@ -1711,11 +1866,32 @@ export default class bybit extends bybitRest {
         //
         //   { code: '-10009', desc: "Invalid period!" }
         //
-        const code = this.safeString2(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"
+        //   }
+        //
+        const code = this.safeStringN(message, ['code', 'ret_code', 'retCode']);
         try {
-            if (code !== undefined) {
+            if (code !== undefined && code !== '0') {
                 const feedback = this.id + ' ' + this.json(message);
                 this.throwExactlyMatchedException(this.exceptions['exact'], code, feedback);
+                const msg = this.safeString2(message, 'retMsg', 'ret_msg');
+                this.throwBroadlyMatchedException(this.exceptions['broad'], msg, feedback);
+                throw new ExchangeError(feedback);
             }
             const success = this.safeValue(message, 'success');
             if (success !== undefined && !success) {
@@ -1740,7 +1916,8 @@ export default class bybit extends bybitRest {
                 }
             }
             else {
-                client.reject(error);
+                const messageHash = this.safeString(message, 'reqId');
+                client.reject(error, messageHash);
             }
             return true;
         }
@@ -1762,17 +1939,12 @@ export default class bybit extends bybitRest {
             return;
         }
         // pong
-        const op = this.safeString(message, 'op');
-        if (op === 'pong') {
-            this.handlePong(client, message);
-            return;
-        }
         const event = this.safeString(message, 'event');
         if (event === 'sub') {
             this.handleSubscriptionStatus(client, message);
             return;
         }
-        const topic = this.safeString(message, 'topic', '');
+        const topic = this.safeString2(message, 'topic', 'op');
         const methods = {
             'orderbook': this.handleOrderBook,
             'kline': this.handleOHLCV,
@@ -1788,6 +1960,11 @@ export default class bybit extends bybitRest {
             'ticketInfo': this.handleMyTrades,
             'user.openapi.perp.trade': this.handleMyTrades,
             'position': this.handlePositions,
+            'pong': this.handlePong,
+            'order.create': this.handleOrderWs,
+            'order.amend': this.handleOrderWs,
+            'order.cancel': this.handleOrderWs,
+            'auth': this.handleAuthenticate,
         };
         const exacMethod = this.safeValue(methods, topic);
         if (exacMethod !== undefined) {
@@ -1805,7 +1982,7 @@ export default class bybit extends bybitRest {
         }
         // unified auth acknowledgement
         const type = this.safeString(message, 'type');
-        if ((op === 'auth') || (type === 'AUTH_RESP')) {
+        if (type === 'AUTH_RESP') {
             this.handleAuthenticate(client, message);
         }
     }
@@ -1838,9 +2015,17 @@ export default class bybit extends bybitRest {
         //        "conn_id": "ce3dpomvha7dha97tvp0-2xh"
         //    }
         //
+        //    {
+        //        "retCode":0,
+        //        "retMsg":"OK",
+        //        "op":"auth",
+        //        "connId":"cojifin88smerbj9t560-404"
+        //    }
+        //
         const success = this.safeValue(message, 'success');
+        const code = this.safeInteger(message, 'retCode');
         const messageHash = 'authenticated';
-        if (success) {
+        if (success || code === 0) {
             const future = this.safeValue(client.futures, messageHash);
             future.resolve(true);
         }

package/js/src/pro/coinbase.d.ts

@@ -3,13 +3,17 @@ import { Strings, Tickers, Ticker, Int, Trade, OrderBook, Order, Str } from '../
 export default class coinbase extends coinbaseRest {
     describe(): any;
     subscribe(name: string, isPrivate: boolean, symbol?: any, params?: {}): Promise<any>;
+    subscribeMultiple(name: string, isPrivate: boolean, symbols?: Strings, params?: {}): Promise<any>;
+    createWSAuth(name: string, productIds: string[]): {};
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTickers(client: any, message: any): any;
     parseWsTicker(ticker: any, market?: any): Ticker;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
     handleTrade(client: any, message: any): any;
     handleOrder(client: any, message: any): any;
     parseWsOrder(order: any, market?: any): Order;