ccxt 4.4.11 → 4.4.13

package/js/src/okx.js

@@ -98,6 +98,7 @@ export default class okx extends Exchange {
                 'fetchMarketLeverageTiers': true,
                 'fetchMarkets': true,
                 'fetchMarkOHLCV': true,
+                'fetchMarkPrices': true,
                 'fetchMySettlementHistory': false,
                 'fetchMyTrades': true,
                 'fetchOHLCV': true,
@@ -1804,6 +1805,13 @@ export default class okx extends Exchange {
         return this.parseOrderBook(first, symbol, timestamp);
     }
     parseTicker(ticker, market = undefined) {
+        //
+        //      {
+        //          "instType":"SWAP",
+        //          "instId":"BTC-USDT-SWAP",
+        //          "markPx":"200",
+        //          "ts":"1597026383085"
+        //      }
         //
         //     {
         //         "instType": "SPOT",
@@ -1855,6 +1863,7 @@ export default class okx extends Exchange {
             'average': undefined,
             'baseVolume': baseVolume,
             'quoteVolume': quoteVolume,
+            'markPrice': this.safeString(ticker, 'markPx'),
             'info': ticker,
         }, market);
     }
@@ -1962,6 +1971,38 @@ export default class okx extends Exchange {
         const tickers = this.safeList(response, 'data', []);
         return this.parseTickers(tickers, symbols);
     }
+    async fetchMarkPrices(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name okx#fetchMarkPrices
+         * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
+         * @see https://www.okx.com/docs-v5/en/#public-data-rest-api-get-mark-price
+         * @param {string[]} [symbols] unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols);
+        const market = this.getMarketFromSymbols(symbols);
+        let marketType = undefined;
+        [marketType, params] = this.handleMarketTypeAndParams('fetchTickers', market, params, 'swap');
+        const request = {
+            'instType': this.convertToInstrumentType(marketType),
+        };
+        if (marketType === 'option') {
+            const defaultUnderlying = this.safeString(this.options, 'defaultUnderlying', 'BTC-USD');
+            const currencyId = this.safeString2(params, 'uly', 'marketId', defaultUnderlying);
+            if (currencyId === undefined) {
+                throw new ArgumentsRequired(this.id + ' fetchTickers() requires an underlying uly or marketId parameter for options markets');
+            }
+            else {
+                request['uly'] = currencyId;
+            }
+        }
+        const response = await this.publicGetPublicMarkPrice(this.extend(request, params));
+        const tickers = this.safeList(response, 'data', []);
+        return this.parseTickers(tickers, symbols);
+    }
     parseTrade(trade, market = undefined) {
         //
         // public fetchTrades
@@ -2940,7 +2981,7 @@ export default class okx extends Exchange {
          * @param {string} [params.positionSide] if position mode is one-way: set to 'net', if position mode is hedge-mode: set to 'long' or 'short'
          * @param {string} [params.trailingPercent] the percent to trail away from the current market price
          * @param {string} [params.tpOrdKind] 'condition' or 'limit', the default is 'condition'
-         * @param {string} [params.hedged] true/false, to automatically set exchange-specific params needed when trading in hedge mode
+         * @param {bool} [params.hedged] *swap and future only* true for hedged mode, false for one way mode
          * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
@@ -4828,38 +4869,30 @@ export default class okx extends Exchange {
          * @see https://www.okx.com/docs-v5/en/#funding-account-rest-api-get-deposit-address
          * @param {string} code unified currency code
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.network] the network name for the deposit address
          * @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
          */
+        await this.loadMarkets();
         const rawNetwork = this.safeStringUpper(params, 'network');
-        const networks = this.safeValue(this.options, 'networks', {});
-        const network = this.safeString(networks, rawNetwork, rawNetwork);
         params = this.omit(params, 'network');
+        code = this.safeCurrencyCode(code);
+        const network = this.networkIdToCode(rawNetwork, code);
         const response = await this.fetchDepositAddressesByNetwork(code, params);
-        let result = undefined;
-        if (network === undefined) {
-            result = this.safeValue(response, code);
+        if (network !== undefined) {
+            const result = this.safeDict(response, network);
             if (result === undefined) {
-                const alias = this.safeString(networks, code, code);
-                result = this.safeValue(response, alias);
-                if (result === undefined) {
-                    const defaultNetwork = this.safeString(this.options, 'defaultNetwork', 'ERC20');
-                    result = this.safeValue(response, defaultNetwork);
-                    if (result === undefined) {
-                        const values = Object.values(response);
-                        result = this.safeValue(values, 0);
-                        if (result === undefined) {
-                            throw new InvalidAddress(this.id + ' fetchDepositAddress() cannot find deposit address for ' + code);
-                        }
-                    }
-                }
+                throw new InvalidAddress(this.id + ' fetchDepositAddress() cannot find ' + network + ' deposit address for ' + code);
             }
             return result;
         }
-        result = this.safeValue(response, network);
-        if (result === undefined) {
-            throw new InvalidAddress(this.id + ' fetchDepositAddress() cannot find ' + network + ' deposit address for ' + code);
+        const codeNetwork = this.networkIdToCode(code, code);
+        if (codeNetwork in response) {
+            return response[codeNetwork];
         }
-        return result;
+        // if the network is not specified, return the first address
+        const keys = Object.keys(response);
+        const first = this.safeString(keys, 0);
+        return this.safeDict(response, first);
     }
     async withdraw(code, amount, address, tag = undefined, params = {}) {
         /**

package/js/src/oxfun.js

@@ -862,6 +862,7 @@ export default class oxfun extends Exchange {
             'average': undefined,
             'baseVolume': this.safeString(ticker, 'currencyVolume24h'),
             'quoteVolume': undefined,
+            'markPrice': this.safeString(ticker, 'markPrice'),
             'info': ticker,
         }, market);
     }

package/js/src/paradex.js

@@ -671,6 +671,7 @@ export default class paradex extends Exchange {
             'average': undefined,
             'baseVolume': undefined,
             'quoteVolume': this.safeString(ticker, 'volume_24h'),
+            'markPrice': this.safeString(ticker, 'mark_price'),
             'info': ticker,
         }, market);
     }

package/js/src/phemex.js

@@ -2498,6 +2498,8 @@ export default class phemex extends Exchange {
          * @param {float} [params.takeProfit.triggerPrice] take profit trigger price
          * @param {object} [params.stopLoss] *swap only* *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered (perpetual swap markets only)
          * @param {float} [params.stopLoss.triggerPrice] stop loss trigger price
+         * @param {string} [params.posSide] *swap only* "Merged" for one way mode, "Long" for buy side of hedged mode, "Short" for sell side of hedged mode
+         * @param {bool} [params.hedged] *swap only* true for hedged mode, false for one way mode, default is false
          * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
@@ -2599,15 +2601,22 @@ export default class phemex extends Exchange {
             }
         }
         else if (market['swap']) {
+            const hedged = this.safeBool(params, 'hedged', false);
+            params = this.omit(params, 'hedged');
             let posSide = this.safeStringLower(params, 'posSide');
             if (posSide === undefined) {
-                posSide = 'Merged';
+                if (hedged) {
+                    if (reduceOnly) {
+                        side = (side === 'buy') ? 'sell' : 'buy';
+                    }
+                    posSide = (side === 'buy') ? 'Long' : 'Short';
+                }
+                else {
+                    posSide = 'Merged';
+                }
             }
             posSide = this.capitalize(posSide);
             request['posSide'] = posSide;
-            if (reduceOnly !== undefined) {
-                request['reduceOnly'] = reduceOnly;
-            }
             if (market['settle'] === 'USDT') {
                 request['orderQtyRq'] = amount;
             }

package/js/src/poloniex.js

@@ -630,6 +630,7 @@ export default class poloniex extends Exchange {
             'average': undefined,
             'baseVolume': this.safeString(ticker, 'quantity'),
             'quoteVolume': this.safeString(ticker, 'amount'),
+            'markPrice': this.safeString(ticker, 'markPrice'),
             'info': ticker,
         }, market);
     }

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

@@ -22,6 +22,8 @@ export default class binance extends binanceRest {
             watchPositions: boolean;
             watchTicker: boolean;
             watchTickers: boolean;
+            watchMarkPrices: boolean;
+            watchMarkPrice: boolean;
             watchTrades: boolean;
             watchTradesForSymbols: boolean;
             createOrderWs: boolean;
@@ -136,6 +138,7 @@ export default class binance extends binanceRest {
             tickerChannelsMap: {
                 '24hrTicker': string;
                 '24hrMiniTicker': string;
+                markPriceUpdate: string;
                 '1hTicker': string;
                 '4hTicker': string;
                 '1dTicker': string;
@@ -181,6 +184,8 @@ export default class binance extends binanceRest {
     fetchOHLCVWs(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleFetchOHLCV(client: Client, message: any): void;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchMarkPrice(symbol: string, params?: {}): Promise<Ticker>;
+    watchMarkPrices(symbols?: Strings, params?: {}): Promise<Tickers>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     unWatchTickers(symbols?: Strings, params?: {}): Promise<any>;
     unWatchTicker(symbol: string, params?: {}): Promise<any>;

package/js/src/pro/binance.js

@@ -39,6 +39,8 @@ export default class binance extends binanceRest {
                 'watchPositions': true,
                 'watchTicker': true,
                 'watchTickers': true,
+                'watchMarkPrices': true,
+                'watchMarkPrice': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': true,
                 'createOrderWs': true,
@@ -155,6 +157,7 @@ export default class binance extends binanceRest {
                 'tickerChannelsMap': {
                     '24hrTicker': 'ticker',
                     '24hrMiniTicker': 'miniTicker',
+                    'markPriceUpdate': 'markPrice',
                     // rolling window tickers
                     '1hTicker': 'ticker_1h',
                     '4hTicker': 'ticker_4h',
@@ -1770,6 +1773,44 @@ export default class binance extends binanceRest {
         const tickers = await this.watchTickers([symbol], this.extend(params, { 'callerMethodName': 'watchTicker' }));
         return tickers[symbol];
     }
+    async watchMarkPrice(symbol, params = {}) {
+        /**
+         * @method
+         * @name binance#watchMarkPrice
+         * @see https://developers.binance.com/docs/derivatives/usds-margined-futures/websocket-market-streams/Mark-Price-Stream
+         * @description watches a mark price for a specific market
+         * @param {string} symbol unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.use1sFreq] *default is true* if set to true, the mark price will be updated every second, otherwise every 3 seconds
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbol = this.symbol(symbol);
+        const tickers = await this.watchMarkPrices([symbol], this.extend(params, { 'callerMethodName': 'watchMarkPrice' }));
+        return tickers[symbol];
+    }
+    async watchMarkPrices(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name binance#watchMarkPrices
+         * @see https://developers.binance.com/docs/derivatives/usds-margined-futures/websocket-market-streams/Mark-Price-Stream-for-All-market
+         * @description watches the mark price for all markets
+         * @param {string[]} symbols unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.use1sFreq] *default is true* if set to true, the mark price will be updated every second, otherwise every 3 seconds
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        let channelName = undefined;
+        // for now watchmarkPrice uses the same messageHash as watchTicker
+        // so it's impossible to watch both at the same time
+        // refactor this to use different messageHashes
+        [channelName, params] = this.handleOptionAndParams(params, 'watchMarkPrices', 'name', 'markPrice');
+        const newTickers = await this.watchMultiTickerHelper('watchMarkPrices', channelName, symbols, params);
+        if (this.newUpdates) {
+            return newTickers;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
     async watchTickers(symbols = undefined, params = {}) {
         /**
          * @method
@@ -1928,13 +1969,17 @@ export default class binance extends binanceRest {
     async watchMultiTickerHelper(methodName, channelName, symbols = undefined, params = {}) {
         await this.loadMarkets();
         symbols = this.marketSymbols(symbols, undefined, true, false, true);
+        const isBidAsk = (channelName === 'bookTicker');
+        const isMarkPrice = (channelName === 'markPrice');
+        const use1sFreq = this.safeBool(params, 'use1sFreq', true);
         let firstMarket = undefined;
         let marketType = undefined;
         const symbolsDefined = (symbols !== undefined);
         if (symbolsDefined) {
             firstMarket = this.market(symbols[0]);
         }
-        [marketType, params] = this.handleMarketTypeAndParams(methodName, firstMarket, params);
+        const defaultMarket = (isMarkPrice) ? 'swap' : 'spot';
+        [marketType, params] = this.handleMarketTypeAndParams(methodName, firstMarket, params, defaultMarket);
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams(methodName, firstMarket, params);
         let rawMarketType = undefined;
@@ -1950,14 +1995,17 @@ export default class binance extends binanceRest {
         else {
             throw new NotSupported(this.id + ' ' + methodName + '() does not support options markets');
         }
-        const isBidAsk = (channelName === 'bookTicker');
         const subscriptionArgs = [];
         const messageHashes = [];
+        let suffix = '';
+        if (isMarkPrice) {
+            suffix = (use1sFreq) ? '@1s' : '';
+        }
         if (symbolsDefined) {
             for (let i = 0; i < symbols.length; i++) {
                 const symbol = symbols[i];
                 const market = this.market(symbol);
-                subscriptionArgs.push(market['lowercaseId'] + '@' + channelName);
+                subscriptionArgs.push(market['lowercaseId'] + '@' + channelName + suffix);
                 messageHashes.push(this.getMessageHash(channelName, market['symbol'], isBidAsk));
             }
         }
@@ -1968,6 +2016,9 @@ export default class binance extends binanceRest {
                 }
                 subscriptionArgs.push('!' + channelName);
             }
+            else if (isMarkPrice) {
+                subscriptionArgs.push('!' + channelName + '@arr' + suffix);
+            }
             else {
                 subscriptionArgs.push('!' + channelName + '@arr');
             }
@@ -2000,6 +2051,17 @@ export default class binance extends binanceRest {
         }
     }
     parseWsTicker(message, marketType) {
+        // markPrice
+        //   {
+        //       "e": "markPriceUpdate",   // Event type
+        //       "E": 1562305380000,       // Event time
+        //       "s": "BTCUSDT",           // Symbol
+        //       "p": "11794.15000000",    // Mark price
+        //       "i": "11784.62659091",    // Index price
+        //       "P": "11784.25641265",    // Estimated Settle Price, only useful in the last hour before the settlement starts
+        //       "r": "0.00038167",        // Funding rate
+        //       "T": 1562306400000        // Next funding time
+        //   }
         //
         // ticker
         //     {
@@ -2057,10 +2119,23 @@ export default class binance extends binanceRest {
         //         "time":1589437530011,
         //      }
         //
+        const marketId = this.safeString2(message, 's', 'symbol');
+        const symbol = this.safeSymbol(marketId, undefined, undefined, marketType);
         let event = this.safeString(message, 'e', 'bookTicker');
         if (event === '24hrTicker') {
             event = 'ticker';
         }
+        if (event === 'markPriceUpdate') {
+            // handle this separately because some fields clash with the ticker fields
+            return this.safeTicker({
+                'symbol': symbol,
+                'timestamp': this.safeInteger(message, 'E'),
+                'datetime': this.iso8601(this.safeInteger(message, 'E')),
+                'info': message,
+                'markPrice': this.safeString(message, 'p'),
+                'indexPrice': this.safeString(message, 'i'),
+            });
+        }
         let timestamp = undefined;
         if (event === 'bookTicker') {
             // take the event timestamp, if available, for spot tickers it is not
@@ -2070,8 +2145,6 @@ export default class binance extends binanceRest {
             // take the timestamp of the closing price for candlestick streams
             timestamp = this.safeIntegerN(message, ['C', 'E', 'time']);
         }
-        const marketId = this.safeString2(message, 's', 'symbol');
-        const symbol = this.safeSymbol(marketId, undefined, undefined, marketType);
         const market = this.safeMarket(marketId, undefined, undefined, marketType);
         const last = this.safeString2(message, 'c', 'price');
         return this.safeTicker({
@@ -4240,6 +4313,8 @@ export default class binance extends binanceRest {
             '1dTicker': this.handleTickers,
             '24hrTicker': this.handleTickers,
             '24hrMiniTicker': this.handleTickers,
+            'markPriceUpdate': this.handleTickers,
+            'markPriceUpdate@arr': this.handleTickers,
             'bookTicker': this.handleBidsAsks,
             'outboundAccountPosition': this.handleBalance,
             'balanceUpdate': this.handleBalance,

package/js/src/pro/bitfinex.js

@@ -224,15 +224,15 @@ export default class bitfinex extends bitfinexRest {
         if ((last !== undefined) && (change !== undefined)) {
             open = Precise.stringSub(last, change);
         }
-        const result = {
+        const result = this.safeTicker({
             'symbol': symbol,
             'timestamp': undefined,
             'datetime': undefined,
-            'high': this.safeFloat(message, 9),
-            'low': this.safeFloat(message, 10),
-            'bid': this.safeFloat(message, 1),
+            'high': this.safeString(message, 9),
+            'low': this.safeString(message, 10),
+            'bid': this.safeString(message, 1),
             'bidVolume': undefined,
-            'ask': this.safeFloat(message, 3),
+            'ask': this.safeString(message, 3),
             'askVolume': undefined,
             'vwap': undefined,
             'open': this.parseNumber(open),
@@ -240,12 +240,12 @@ export default class bitfinex extends bitfinexRest {
             'last': this.parseNumber(last),
             'previousClose': undefined,
             'change': this.parseNumber(change),
-            'percentage': this.safeFloat(message, 6),
+            'percentage': this.safeString(message, 6),
             'average': undefined,
-            'baseVolume': this.safeFloat(message, 8),
+            'baseVolume': this.safeString(message, 8),
             'quoteVolume': undefined,
             'info': message,
-        };
+        });
         this.tickers[symbol] = result;
         client.resolve(result, messageHash);
     }

package/js/src/pro/krakenfutures.js

@@ -1065,6 +1065,8 @@ export default class krakenfutures extends krakenfuturesRest {
             'average': undefined,
             'baseVolume': this.safeString(ticker, 'volume'),
             'quoteVolume': this.safeString(ticker, 'volumeQuote'),
+            'markPrice': this.safeString(ticker, 'markPrice'),
+            'indexPrice': this.safeString(ticker, 'index'),
         });
     }
     handleOrderBookSnapshot(client, message) {

package/js/src/pro/phemex.js

@@ -134,6 +134,8 @@ export default class phemex extends phemexRest {
             'average': average,
             'baseVolume': baseVolume,
             'quoteVolume': quoteVolume,
+            'markPrice': this.parseNumber(this.fromEp(this.safeString(ticker, 'markPrice'), market)),
+            'indexPrice': this.parseNumber(this.fromEp(this.safeString(ticker, 'indexPrice'), market)),
             'info': ticker,
         };
         return result;

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

@@ -17,6 +17,9 @@ export default class woo extends wooRest {
     handleTicker(client: Client, message: any): any;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTickers(client: Client, message: any): void;
+    watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
+    handleBidAsk(client: Client, message: any): void;
+    parseWsBidAsk(ticker: any, market?: any): Ticker;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;

package/js/src/pro/woo.js

@@ -23,6 +23,7 @@ export default class woo extends wooRest {
                 'watchOrders': true,
                 'watchTicker': true,
                 'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': false,
                 'watchPositions': true,
@@ -404,6 +405,77 @@ export default class woo extends wooRest {
         }
         client.resolve(result, topic);
     }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name woo#watchBidsAsks
+         * @see https://docs.woox.io/#bbos
+         * @description watches best bid & ask for symbols
+         * @param {string[]} symbols unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        const name = 'bbos';
+        const topic = name;
+        const request = {
+            'event': 'subscribe',
+            'topic': topic,
+        };
+        const message = this.extend(request, params);
+        const tickers = await this.watchPublic(topic, message);
+        if (this.newUpdates) {
+            return tickers;
+        }
+        return this.filterByArray(this.bidsasks, 'symbol', symbols);
+    }
+    handleBidAsk(client, message) {
+        //
+        //     {
+        //         "topic": "bbos",
+        //         "ts": 1618822376000,
+        //         "data": [
+        //             {
+        //                 "symbol": "SPOT_FIL_USDT",
+        //                 "ask": 159.0318,
+        //                 "askSize": 370.43,
+        //                 "bid": 158.9158,
+        //                 "bidSize": 16
+        //             }
+        //         ]
+        //     }
+        //
+        const topic = this.safeString(message, 'topic');
+        const data = this.safeList(message, 'data', []);
+        const timestamp = this.safeInteger(message, 'ts');
+        const result = {};
+        for (let i = 0; i < data.length; i++) {
+            const ticker = this.safeDict(data, i);
+            ticker['ts'] = timestamp;
+            const parsedTicker = this.parseWsBidAsk(ticker);
+            const symbol = parsedTicker['symbol'];
+            this.bidsasks[symbol] = parsedTicker;
+            result[symbol] = parsedTicker;
+        }
+        client.resolve(result, topic);
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const marketId = this.safeString(ticker, 'symbol');
+        market = this.safeMarket(marketId, market);
+        const symbol = this.safeString(market, 'symbol');
+        const timestamp = this.safeInteger(ticker, 'ts');
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'ask': this.safeString(ticker, 'ask'),
+            'askVolume': this.safeString(ticker, 'askSize'),
+            'bid': this.safeString(ticker, 'bid'),
+            'bidVolume': this.safeString(ticker, 'bidSize'),
+            'info': ticker,
+        }, market);
+    }
     async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -1184,6 +1256,7 @@ export default class woo extends wooRest {
             'trade': this.handleTrade,
             'balance': this.handleBalance,
             'position': this.handlePositions,
+            'bbos': this.handleBidAsk,
         };
         const event = this.safeString(message, 'event');
         let method = this.safeValue(methods, event);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.4.11",
+  "version": "4.4.13",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges",
   "unpkg": "dist/ccxt.browser.min.js",
   "type": "module",
@@ -163,7 +163,7 @@
     "as-table": "1.0.37",
     "asciichart": "^1.5.25",
     "assert": "^2.0.0",
-    "ast-transpiler": "^0.0.44",
+    "ast-transpiler": "^0.0.56",
     "docsify": "^4.11.4",
     "eslint": "8.22.0",
     "eslint-config-airbnb-base": "15.0.0",