ccxt 4.2.70 → 4.2.72

package/js/src/mexc.js

@@ -44,6 +44,7 @@ export default class mexc extends Exchange {
                 'createMarketSellOrderWithCost': false,
                 'createOrder': true,
                 'createOrders': true,
+                'createPostOnlyOrder': true,
                 'createReduceOnlyOrder': true,
                 'deposit': undefined,
                 'editOrder': undefined,
@@ -2210,6 +2211,14 @@ export default class mexc extends Exchange {
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @param {string} [params.marginMode] only 'isolated' is supported for spot-margin trading
          * @param {float} [params.triggerPrice] The price at which a trigger order is triggered at
+         * @param {bool} [params.postOnly] if true, the order will only be posted if it will be a maker order
+         * @param {bool} [params.reduceOnly] *contract only* indicates if this order is to reduce the size of a position
+         *
+         * EXCHANGE SPECIFIC PARAMETERS
+         * @param {int} [params.leverage] *contract only* leverage is necessary on isolated margin
+         * @param {long} [params.positionId] *contract only* it is recommended to fill in this parameter when closing a position
+         * @param {string} [params.externalOid] *contract only* external order ID
+         * @param {int} [params.positionMode] *contract only*  1:hedge, 2:one-way, default: the user's current config
          * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();

package/js/src/poloniexfutures.d.ts

@@ -53,7 +53,7 @@ export default class poloniexfutures extends Exchange {
     fetchOrdersByStatus(status: any, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    fetchOrder(id?: string, symbol?: Str, params?: {}): Promise<Order>;
+    fetchOrder(id?: Str, symbol?: Str, params?: {}): Promise<Order>;
     parseOrder(order: any, market?: Market): Order;
     fetchFundingRate(symbol: string, params?: {}): Promise<{
         info: any;
@@ -75,7 +75,7 @@ export default class poloniexfutures extends Exchange {
         previousFundingDatetime: string;
     }>;
     fetchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    setMarginMode(marginMode: string, symbol?: string, params?: {}): Promise<any>;
+    setMarginMode(marginMode: string, symbol?: Str, params?: {}): Promise<any>;
     sign(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any): {
         url: any;
         method: string;

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

@@ -20,6 +20,7 @@ export default class bingx extends bingxRest {
     setBalanceCache(client: Client, type: any, subscriptionHash: any, params: any): void;
     loadBalanceSnapshot(client: any, messageHash: any, type: any): Promise<void>;
     handleErrorMessage(client: any, message: any): boolean;
+    keepAliveListenKey(params?: {}): Promise<void>;
     authenticate(params?: {}): Promise<void>;
     pong(client: any, message: any): Promise<void>;
     handleOrder(client: any, message: any): void;

package/js/src/pro/bingx.js

@@ -765,21 +765,44 @@ export default class bingx extends bingxRest {
         }
         return true;
     }
-    async authenticate(params = {}) {
-        const time = this.milliseconds();
+    async keepAliveListenKey(params = {}) {
         const listenKey = this.safeString(this.options, 'listenKey');
         if (listenKey === undefined) {
-            const response = await this.userAuthPrivatePostUserDataStream();
-            this.options['listenKey'] = this.safeString(response, 'listenKey');
-            this.options['lastAuthenticatedTime'] = time;
+            // A network error happened: we can't renew a listen key that does not exist.
             return;
         }
+        try {
+            await this.userAuthPrivatePutUserDataStream({ 'listenKey': listenKey }); // extend the expiry
+        }
+        catch (error) {
+            const types = ['spot', 'swap'];
+            for (let i = 0; i < types.length; i++) {
+                const type = types[i];
+                const url = this.urls['api']['ws'][type] + '?listenKey=' + listenKey;
+                const client = this.client(url);
+                const messageHashes = Object.keys(client.futures);
+                for (let j = 0; j < messageHashes.length; j++) {
+                    const messageHash = messageHashes[j];
+                    client.reject(error, messageHash);
+                }
+            }
+            this.options['listenKey'] = undefined;
+            this.options['lastAuthenticatedTime'] = 0;
+            return;
+        }
+        // whether or not to schedule another listenKey keepAlive request
+        const listenKeyRefreshRate = this.safeInteger(this.options, 'listenKeyRefreshRate', 3600000);
+        this.delay(listenKeyRefreshRate, this.keepAliveListenKey, params);
+    }
+    async authenticate(params = {}) {
+        const time = this.milliseconds();
         const lastAuthenticatedTime = this.safeInteger(this.options, 'lastAuthenticatedTime', 0);
         const listenKeyRefreshRate = this.safeInteger(this.options, 'listenKeyRefreshRate', 3600000); // 1 hour
         if (time - lastAuthenticatedTime > listenKeyRefreshRate) {
-            const response = await this.userAuthPrivatePutUserDataStream({ 'listenKey': listenKey }); // extend the expiry
+            const response = await this.userAuthPrivatePostUserDataStream();
             this.options['listenKey'] = this.safeString(response, 'listenKey');
             this.options['lastAuthenticatedTime'] = time;
+            this.delay(listenKeyRefreshRate, this.keepAliveListenKey, params);
         }
     }
     async pong(client, message) {

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

@@ -24,21 +24,21 @@ export default class bitvavo extends bitvavoRest {
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: number, price?: number, params?: {}): Promise<Order>;
-    cancelOrderWs(id: string, symbol?: string, params?: {}): Promise<any>;
-    cancelAllOrdersWs(symbol?: string, params?: {}): Promise<any>;
+    cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<any>;
+    cancelAllOrdersWs(symbol?: Str, params?: {}): Promise<any>;
     handleMultipleOrders(client: Client, message: any): void;
-    fetchOrderWs(id: string, symbol?: string, params?: {}): Promise<Order>;
-    fetchOrdersWs(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    fetchOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     watchRequest(action: any, request: any): Promise<any>;
-    fetchOpenOrdersWs(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    fetchMyTradesWs(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    fetchOpenOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchMyTradesWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrades(client: Client, message: any): void;
     withdrawWs(code: string, amount: any, address: any, tag?: any, params?: {}): Promise<any>;
     handleWithdraw(client: Client, message: any): void;
-    fetchWithdrawalsWs(code?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    fetchWithdrawalsWs(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     handleWithdraws(client: Client, message: any): void;
     fetchOHLCVWs(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    fetchDepositsWs(code?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    fetchDepositsWs(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     handleDeposits(client: Client, message: any): void;
     fetchTradingFeesWs(params?: {}): Promise<any>;
     fetchMarketsWs(params?: {}): Promise<any>;

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

@@ -4,7 +4,7 @@ import Client from '../base/ws/Client.js';
 export default class bybit extends bybitRest {
     describe(): any;
     requestId(): any;
-    getUrlByMarketType(symbol?: Str, isPrivate?: boolean, method?: string, params?: {}): any;
+    getUrlByMarketType(symbol?: Str, isPrivate?: boolean, method?: Str, params?: {}): any;
     cleanParams(params: any): any;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;

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

@@ -16,7 +16,7 @@ export default class cex extends cexRest {
     handleTicker(client: Client, message: any): void;
     parseWsTicker(ticker: any, market?: any): Ticker;
     fetchBalanceWs(params?: {}): Promise<Balances>;
-    watchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTransaction(client: Client, message: any): void;
     handleMyTrades(client: Client, message: any): void;
@@ -37,12 +37,12 @@ export default class cex extends cexRest {
     handleOHLCV24(client: Client, message: any): any;
     handleOHLCV1m(client: Client, message: any): void;
     handleOHLCV(client: Client, message: any): void;
-    fetchOrderWs(id: string, symbol?: string, params?: {}): Promise<Order>;
-    fetchOpenOrdersWs(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    fetchOpenOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: number, price?: number, params?: {}): Promise<Order>;
-    cancelOrderWs(id: string, symbol?: string, params?: {}): Promise<Order>;
-    cancelOrdersWs(ids: string[], symbol?: string, params?: {}): Promise<Order[]>;
+    cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    cancelOrdersWs(ids: string[], symbol?: Str, params?: {}): Promise<Order[]>;
     resolveData(client: Client, message: any): void;
     handleConnected(client: Client, message: any): any;
     handleErrorMessage(client: Client, message: any): void;

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

@@ -1,5 +1,5 @@
 import coinbaseRest from '../coinbase.js';
-import { Strings, Tickers, Ticker, Int, Trade, OrderBook, Order } from '../base/types.js';
+import { Strings, Tickers, Ticker, Int, Trade, OrderBook, Order, Str } from '../base/types.js';
 export default class coinbase extends coinbaseRest {
     describe(): any;
     subscribe(name: any, symbol?: any, params?: {}): Promise<any>;
@@ -8,7 +8,7 @@ export default class coinbase extends coinbaseRest {
     handleTickers(client: any, message: any): any;
     parseWsTicker(ticker: any, market?: any): Ticker;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    watchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleTrade(client: any, message: any): any;
     handleOrder(client: any, message: any): any;

package/js/src/pro/hitbtc.js

@@ -250,7 +250,10 @@ export default class hitbtc extends hitbtcRest {
         //        }
         //    }
         //
-        const data = this.safeValue2(message, 'snapshot', 'update', {});
+        const snapshot = this.safeDict(message, 'snapshot');
+        const update = this.safeDict(message, 'update');
+        const data = snapshot ? snapshot : update;
+        const type = snapshot ? 'snapshot' : 'update';
         const marketIds = Object.keys(data);
         for (let i = 0; i < marketIds.length; i++) {
             const marketId = marketIds[i];
@@ -259,17 +262,23 @@ export default class hitbtc extends hitbtcRest {
             const item = data[marketId];
             const messageHash = 'orderbooks::' + symbol;
             if (!(symbol in this.orderbooks)) {
-                const subscription = this.safeValue(client.subscriptions, messageHash, {});
+                const subscription = this.safeDict(client.subscriptions, messageHash, {});
                 const limit = this.safeInteger(subscription, 'limit');
                 this.orderbooks[symbol] = this.orderBook({}, limit);
             }
+            const orderbook = this.orderbooks[symbol];
             const timestamp = this.safeInteger(item, 't');
             const nonce = this.safeInteger(item, 's');
-            const orderbook = this.orderbooks[symbol];
-            const asks = this.safeValue(item, 'a', []);
-            const bids = this.safeValue(item, 'b', []);
-            this.handleDeltas(orderbook['asks'], asks);
-            this.handleDeltas(orderbook['bids'], bids);
+            if (type === 'snapshot') {
+                const parsedSnapshot = this.parseOrderBook(item, symbol, timestamp, 'b', 'a');
+                orderbook.reset(parsedSnapshot);
+            }
+            else {
+                const asks = this.safeList(item, 'a', []);
+                const bids = this.safeList(item, 'b', []);
+                this.handleDeltas(orderbook['asks'], asks);
+                this.handleDeltas(orderbook['bids'], bids);
+            }
             orderbook['timestamp'] = timestamp;
             orderbook['datetime'] = this.iso8601(timestamp);
             orderbook['nonce'] = nonce;

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

@@ -0,0 +1,23 @@
+import hyperliquidRest from '../hyperliquid.js';
+import Client from '../base/ws/Client.js';
+import { Int, Str, Market, OrderBook, Trade, OHLCV, Order } from '../base/types.js';
+export default class hyperliquid extends hyperliquidRest {
+    describe(): any;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    handleOrderBook(client: any, message: any): void;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    handleMyTrades(client: Client, message: any): void;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    handleTrades(client: Client, message: any): void;
+    parseWsTrade(trade: any, market?: Market): Trade;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    handleOHLCV(client: Client, message: any): void;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    handleOrder(client: Client, message: any): void;
+    handleErrorMessage(client: Client, message: any): boolean;
+    handleMessage(client: Client, message: any): void;
+    ping(client: any): {
+        method: string;
+    };
+    handlePong(client: Client, message: any): any;
+}