ccxt 4.3.3 → 4.3.5

package/dist/cjs/src/pro/woo.js

@@ -72,7 +72,6 @@ class woo extends woo$1 {
         return newValue;
     }
     async watchPublic(messageHash, message) {
-        this.checkRequiredUid();
         const url = this.urls['api']['ws']['public'] + '/' + this.uid;
         const requestId = this.requestId(url);
         const subscribe = {

package/dist/cjs/src/whitebit.js

@@ -28,7 +28,7 @@ class whitebit extends whitebit$1 {
                 'swap': false,
                 'future': false,
                 'option': false,
-                'cancelAllOrders': false,
+                'cancelAllOrders': true,
                 'cancelOrder': true,
                 'cancelOrders': false,
                 'createOrder': true,
@@ -173,11 +173,13 @@ class whitebit extends whitebit$1 {
                             'ping',
                             'markets',
                             'futures',
+                            'platform/status',
                         ],
                     },
                     'private': {
                         'post': [
                             'collateral-account/balance',
+                            'collateral-account/balance-summary',
                             'collateral-account/positions/history',
                             'collateral-account/leverage',
                             'collateral-account/positions/open',
@@ -194,21 +196,40 @@ class whitebit extends whitebit$1 {
                             'main-account/withdraw',
                             'main-account/withdraw-pay',
                             'main-account/transfer',
+                            'main-account/smart/plans',
+                            'main-account/smart/investment',
+                            'main-account/smart/investment/close',
+                            'main-account/smart/investments',
+                            'main-account/fee',
+                            'main-account/smart/interest-payment-history',
                             'trade-account/balance',
                             'trade-account/executed-history',
                             'trade-account/order',
                             'trade-account/order/history',
                             'order/collateral/limit',
                             'order/collateral/market',
-                            'order/collateral/trigger_market',
+                            'order/collateral/stop-limit',
+                            'order/collateral/trigger-market',
                             'order/new',
                             'order/market',
                             'order/stock_market',
                             'order/stop_limit',
                             'order/stop_market',
                             'order/cancel',
+                            'order/cancel/all',
+                            'order/kill-switch',
+                            'order/kill-switch/status',
+                            'order/bulk',
+                            'order/modify',
                             'orders',
+                            'oco-orders',
+                            'order/collateral/oco',
+                            'order/oco-cancel',
+                            'order/oto-cancel',
                             'profile/websocket_token',
+                            'convert/estimate',
+                            'convert/confirm',
+                            'convert/history',
                         ],
                     },
                 },
@@ -1257,6 +1278,70 @@ class whitebit extends whitebit$1 {
         }
         return this.parseOrder(response);
     }
+    async editOrder(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name whitebit#editOrder
+         * @description edit a trade order
+         * @see https://docs.whitebit.com/private/http-trade-v4/#modify-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
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        if (id === undefined) {
+            throw new errors.ArgumentsRequired(this.id + ' editOrder() requires a id argument');
+        }
+        if (symbol === undefined) {
+            throw new errors.ArgumentsRequired(this.id + ' editOrder() requires a symbol argument');
+        }
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'orderId': id,
+            'market': market['id'],
+        };
+        const clientOrderId = this.safeString2(params, 'clOrdId', 'clientOrderId');
+        if (clientOrderId !== undefined) {
+            // Update clientOrderId of the order
+            request['clientOrderId'] = clientOrderId;
+        }
+        const isLimitOrder = type === 'limit';
+        const stopPrice = this.safeNumberN(params, ['triggerPrice', 'stopPrice', 'activation_price']);
+        const isStopOrder = (stopPrice !== undefined);
+        params = this.omit(params, ['clOrdId', 'clientOrderId', 'triggerPrice', 'stopPrice']);
+        if (isStopOrder) {
+            request['activation_price'] = this.priceToPrecision(symbol, stopPrice);
+            if (isLimitOrder) {
+                // stop limit order
+                request['amount'] = this.amountToPrecision(symbol, amount);
+                request['price'] = this.priceToPrecision(symbol, price);
+            }
+            else {
+                // stop market order
+                if (side === 'buy') {
+                    // Use total parameter instead of amount for modify buy stop market order
+                    request['total'] = this.amountToPrecision(symbol, amount);
+                }
+                else {
+                    request['amount'] = this.amountToPrecision(symbol, amount);
+                }
+            }
+        }
+        else {
+            request['amount'] = this.amountToPrecision(symbol, amount);
+            if (isLimitOrder) {
+                // limit order
+                request['price'] = this.priceToPrecision(symbol, price);
+            }
+        }
+        const response = await this.v4PrivatePostOrderModify(this.extend(request, params));
+        return this.parseOrder(response);
+    }
     async cancelOrder(id, symbol = undefined, params = {}) {
         /**
          * @method
@@ -1279,6 +1364,51 @@ class whitebit extends whitebit$1 {
         };
         return await this.v4PrivatePostOrderCancel(this.extend(request, params));
     }
+    async cancelAllOrders(symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name whitebit#cancelAllOrders
+         * @description cancel all open orders
+         * @see https://docs.whitebit.com/private/http-trade-v4/#cancel-all-orders
+         * @param {string} symbol unified market symbol, only orders in the market of this symbol are cancelled when symbol is not undefined
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.type] market type, ['swap', 'spot']
+         * @param {boolean} [params.isMargin] cancel all margin orders
+         * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        let market = undefined;
+        const request = {};
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            request['market'] = market['id'];
+        }
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('cancelAllOrders', market, params);
+        const requestType = [];
+        if (type === 'spot') {
+            let isMargin = undefined;
+            [isMargin, params] = this.handleOptionAndParams(params, 'cancelAllOrders', 'isMargin', false);
+            if (isMargin) {
+                requestType.push('margin');
+            }
+            else {
+                requestType.push('spot');
+            }
+        }
+        else if (type === 'swap') {
+            requestType.push('futures');
+        }
+        else {
+            throw new errors.NotSupported(this.id + ' cancelAllOrders() does not support ' + type + ' type');
+        }
+        request['type'] = requestType;
+        const response = await this.v4PrivatePostOrderCancelAll(this.extend(request, params));
+        //
+        // []
+        //
+        return response;
+    }
     parseBalance(response) {
         const balanceKeys = Object.keys(response);
         const result = {};

package/js/ccxt.d.ts

@@ -4,7 +4,7 @@ import * as functions from './src/base/functions.js';
 import * as errors from './src/base/errors.js';
 import type { Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position, FundingRateHistory, Liquidation, FundingHistory, MarginMode, Greeks, Leverage, Leverages, Option, OptionChain, Conversion } from './src/base/types.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
-declare const version = "4.3.2";
+declare const version = "4.3.4";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';

package/js/ccxt.js

@@ -38,7 +38,7 @@ import * as errors from './src/base/errors.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.3.3';
+const version = '4.3.5';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

package/js/src/abstract/whitebit.d.ts

@@ -33,7 +33,9 @@ interface Exchange {
     v4PublicGetPing(params?: {}): Promise<implicitReturnType>;
     v4PublicGetMarkets(params?: {}): Promise<implicitReturnType>;
     v4PublicGetFutures(params?: {}): Promise<implicitReturnType>;
+    v4PublicGetPlatformStatus(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostCollateralAccountBalance(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostCollateralAccountBalanceSummary(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostCollateralAccountPositionsHistory(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostCollateralAccountLeverage(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostCollateralAccountPositionsOpen(params?: {}): Promise<implicitReturnType>;
@@ -50,12 +52,19 @@ interface Exchange {
     v4PrivatePostMainAccountWithdraw(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostMainAccountWithdrawPay(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostMainAccountTransfer(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostMainAccountSmartPlans(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostMainAccountSmartInvestment(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostMainAccountSmartInvestmentClose(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostMainAccountSmartInvestments(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostMainAccountFee(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostMainAccountSmartInterestPaymentHistory(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostTradeAccountBalance(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostTradeAccountExecutedHistory(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostTradeAccountOrder(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostTradeAccountOrderHistory(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostOrderCollateralLimit(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostOrderCollateralMarket(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderCollateralStopLimit(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostOrderCollateralTriggerMarket(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostOrderNew(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostOrderMarket(params?: {}): Promise<implicitReturnType>;
@@ -63,8 +72,20 @@ interface Exchange {
     v4PrivatePostOrderStopLimit(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostOrderStopMarket(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostOrderCancel(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderCancelAll(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderKillSwitch(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderKillSwitchStatus(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderBulk(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderModify(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostOrders(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOcoOrders(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderCollateralOco(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderOcoCancel(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderOtoCancel(params?: {}): Promise<implicitReturnType>;
     v4PrivatePostProfileWebsocketToken(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostConvertEstimate(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostConvertConfirm(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostConvertHistory(params?: {}): Promise<implicitReturnType>;
 }
 declare abstract class Exchange extends _Exchange {
 }

package/js/src/base/Exchange.d.ts

@@ -301,35 +301,55 @@ export default class Exchange {
             cancelAllOrders: any;
             cancelAllOrdersWs: any;
             cancelOrder: boolean;
+            cancelOrderWs: any;
             cancelOrders: any;
             cancelOrdersWs: any;
-            cancelOrderWs: any;
             closeAllPositions: any;
             closePosition: any;
             createDepositAddress: any;
             createLimitBuyOrder: any;
+            createLimitBuyOrderWs: any;
             createLimitOrder: boolean;
+            createLimitOrderWs: any;
             createLimitSellOrder: any;
+            createLimitSellOrderWs: any;
             createMarketBuyOrder: any;
+            createMarketBuyOrderWs: any;
             createMarketBuyOrderWithCost: any;
+            createMarketBuyOrderWithCostWs: any;
             createMarketOrder: boolean;
+            createMarketOrderWs: boolean;
             createMarketOrderWithCost: any;
+            createMarketOrderWithCostWs: any;
             createMarketSellOrder: any;
+            createMarketSellOrderWs: any;
             createMarketSellOrderWithCost: any;
+            createMarketSellOrderWithCostWs: any;
             createOrder: boolean;
+            createOrderWs: any;
             createOrders: any;
             createOrderWithTakeProfitAndStopLoss: any;
-            createOrderWs: any;
+            createOrderWithTakeProfitAndStopLossWs: any;
             createPostOnlyOrder: any;
+            createPostOnlyOrderWs: any;
             createReduceOnlyOrder: any;
+            createReduceOnlyOrderWs: any;
             createStopLimitOrder: any;
+            createStopLimitOrderWs: any;
             createStopLossOrder: any;
+            createStopLossOrderWs: any;
             createStopMarketOrder: any;
+            createStopMarketOrderWs: any;
             createStopOrder: any;
+            createStopOrderWs: any;
             createTakeProfitOrder: any;
+            createTakeProfitOrderWs: any;
             createTrailingAmountOrder: any;
+            createTrailingAmountOrderWs: any;
             createTrailingPercentOrder: any;
+            createTrailingPercentOrderWs: any;
             createTriggerOrder: any;
+            createTriggerOrderWs: any;
             deposit: any;
             editOrder: string;
             editOrderWs: any;
@@ -412,16 +432,20 @@ export default class Exchange {
             fetchOrderWs: any;
             fetchPermissions: any;
             fetchPosition: any;
+            fetchPositionWs: any;
             fetchPositionMode: any;
             fetchPositions: any;
+            fetchPositionsWs: any;
             fetchPositionsForSymbol: any;
+            fetchPositionsForSymbolWs: any;
             fetchPositionsRisk: any;
             fetchPremiumIndexOHLCV: any;
             fetchSettlementHistory: any;
             fetchStatus: any;
             fetchTicker: boolean;
-            fetchTickers: any;
             fetchTickerWs: any;
+            fetchTickers: any;
+            fetchTickersWs: any;
             fetchTime: any;
             fetchTrades: boolean;
             fetchTradesWs: any;
@@ -826,11 +850,14 @@ export default class Exchange {
     editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     fetchPermissions(params?: {}): Promise<{}>;
     fetchPosition(symbol: string, params?: {}): Promise<Position>;
+    fetchPositionWs(symbol: string, params?: {}): Promise<Position[]>;
     watchPosition(symbol?: Str, params?: {}): Promise<Position>;
     watchPositions(symbols?: string[], since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
     watchPositionForSymbols(symbols?: string[], since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
     fetchPositionsForSymbol(symbol: string, params?: {}): Promise<Position[]>;
+    fetchPositionsForSymbolWs(symbol: string, params?: {}): Promise<Position[]>;
     fetchPositions(symbols?: string[], params?: {}): Promise<Position[]>;
+    fetchPositionsWs(symbols?: string[], params?: {}): Promise<Position[]>;
     fetchPositionsRisk(symbols?: string[], params?: {}): Promise<Position[]>;
     fetchBidsAsks(symbols?: string[], params?: {}): Promise<Dictionary<Ticker>>;
     fetchBorrowInterest(code?: Str, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<BorrowInterest[]>;
@@ -869,8 +896,10 @@ export default class Exchange {
     handleErrors(statusCode: any, statusText: any, url: any, method: any, responseHeaders: any, responseBody: any, response: any, requestHeaders: any, requestBody: any): any;
     calculateRateLimiterCost(api: any, method: any, path: any, params: any, config?: {}): any;
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    fetchTickerWs(symbol: string, params?: {}): Promise<Ticker>;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     fetchTickers(symbols?: string[], params?: {}): Promise<Tickers>;
+    fetchTickersWs(symbols?: string[], params?: {}): Promise<Tickers>;
     fetchOrderBooks(symbols?: string[], limit?: Int, params?: {}): Promise<Dictionary<OrderBook>>;
     watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
     watchTickers(symbols?: string[], params?: {}): Promise<Tickers>;
@@ -880,14 +909,22 @@ export default class Exchange {
     fetchUnifiedOrder(order: any, params?: {}): Promise<Order>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     createTrailingAmountOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, trailingAmount?: any, trailingTriggerPrice?: any, params?: {}): Promise<Order>;
+    createTrailingAmountOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, trailingAmount?: any, trailingTriggerPrice?: any, params?: {}): Promise<Order>;
     createTrailingPercentOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, trailingPercent?: any, trailingTriggerPrice?: any, params?: {}): Promise<Order>;
+    createTrailingPercentOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, trailingPercent?: any, trailingTriggerPrice?: any, params?: {}): Promise<Order>;
     createMarketOrderWithCost(symbol: string, side: OrderSide, cost: number, params?: {}): Promise<Order>;
     createMarketBuyOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
     createMarketSellOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
+    createMarketOrderWithCostWs(symbol: string, side: OrderSide, cost: number, params?: {}): Promise<Order>;
     createTriggerOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, triggerPrice?: Num, params?: {}): Promise<Order>;
+    createTriggerOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, triggerPrice?: Num, params?: {}): Promise<Order>;
     createStopLossOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, stopLossPrice?: Num, params?: {}): Promise<Order>;
+    createStopLossOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, stopLossPrice?: Num, params?: {}): Promise<Order>;
     createTakeProfitOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfitPrice?: Num, params?: {}): Promise<Order>;
+    createTakeProfitOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfitPrice?: Num, params?: {}): Promise<Order>;
     createOrderWithTakeProfitAndStopLoss(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfit?: Num, stopLoss?: Num, params?: {}): Promise<Order>;
+    setTakeProfitAndStopLossParams(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfit?: Num, stopLoss?: Num, params?: {}): {};
+    createOrderWithTakeProfitAndStopLossWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfit?: Num, stopLoss?: Num, params?: {}): Promise<Order>;
     createOrders(orders: OrderRequest[], params?: {}): Promise<Order[]>;
     createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<{}>;
@@ -934,11 +971,17 @@ export default class Exchange {
     createExpiredOptionMarket(symbol: string): MarketInterface;
     handleWithdrawTagAndParams(tag: any, params: any): any;
     createLimitOrder(symbol: string, side: OrderSide, amount: number, price: number, params?: {}): Promise<Order>;
+    createLimitOrderWs(symbol: string, side: OrderSide, amount: number, price: number, params?: {}): Promise<Order>;
     createMarketOrder(symbol: string, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
+    createMarketOrderWs(symbol: string, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     createLimitBuyOrder(symbol: string, amount: number, price: number, params?: {}): Promise<Order>;
+    createLimitBuyOrderWs(symbol: string, amount: number, price: number, params?: {}): Promise<Order>;
     createLimitSellOrder(symbol: string, amount: number, price: number, params?: {}): Promise<Order>;
+    createLimitSellOrderWs(symbol: string, amount: number, price: number, params?: {}): Promise<Order>;
     createMarketBuyOrder(symbol: string, amount: number, params?: {}): Promise<Order>;
+    createMarketBuyOrderWs(symbol: string, amount: number, params?: {}): Promise<Order>;
     createMarketSellOrder(symbol: string, amount: number, params?: {}): Promise<Order>;
+    createMarketSellOrderWs(symbol: string, amount: number, params?: {}): Promise<Order>;
     costToPrecision(symbol: string, cost: any): any;
     priceToPrecision(symbol: string, price: any): string;
     amountToPrecision(symbol: string, amount: any): any;
@@ -956,10 +999,15 @@ export default class Exchange {
     implodeHostname(url: string): any;
     fetchMarketLeverageTiers(symbol: string, params?: {}): Promise<any>;
     createPostOnlyOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
+    createPostOnlyOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     createReduceOnlyOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
+    createReduceOnlyOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     createStopOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, stopPrice?: Num, params?: {}): Promise<Order>;
+    createStopOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, stopPrice?: Num, params?: {}): Promise<Order>;
     createStopLimitOrder(symbol: string, side: OrderSide, amount: number, price: number, stopPrice: number, params?: {}): Promise<Order>;
+    createStopLimitOrderWs(symbol: string, side: OrderSide, amount: number, price: number, stopPrice: number, params?: {}): Promise<Order>;
     createStopMarketOrder(symbol: string, side: OrderSide, amount: number, stopPrice: number, params?: {}): Promise<Order>;
+    createStopMarketOrderWs(symbol: string, side: OrderSide, amount: number, stopPrice: number, params?: {}): Promise<Order>;
     safeCurrencyCode(currencyId: Str, currency?: Currency): string;
     filterBySymbolSinceLimit(array: any, symbol?: Str, since?: Int, limit?: Int, tail?: boolean): any;
     filterByCurrencySinceLimit(array: any, code?: any, since?: Int, limit?: Int, tail?: boolean): any;