ccxt 4.3.89 → 4.3.91

package/js/src/kucoin.js

@@ -244,6 +244,7 @@ export default class kucoin extends Exchange {
                         'purchase/orders': 10,
                         // broker
                         'broker/api/rebase/download': 3,
+                        'migrate/user/account/status': 3,
                         // affiliate
                         'affiliate/inviter/statistics': 30,
                     },
@@ -688,6 +689,7 @@ export default class kucoin extends Exchange {
                             'project/marketInterestRate': 'v3',
                             'redeem/orders': 'v3',
                             'purchase/orders': 'v3',
+                            'migrate/user/account/status': 'v3',
                             'margin/symbols': 'v3',
                             'affiliate/inviter/statistics': 'v2',
                             'asset/ndbroker/deposit/list': 'v1',
@@ -1211,6 +1213,30 @@ export default class kucoin extends Exchange {
         }
         return result;
     }
+    async loadMigrationStatus(force = false) {
+        if (!('hfMigrated' in this.options) || force) {
+            const result = await this.privateGetMigrateUserAccountStatus();
+            const data = this.safeDict(result, 'data', {});
+            const status = this.safeInteger(data, 'status');
+            this.options['hfMigrated'] = (status === 2);
+        }
+    }
+    async handleHfAndParams(params = {}) {
+        await this.loadMigrationStatus();
+        const migrated = this.safeBool(this.options, 'hfMigrated');
+        let loadedHf = undefined;
+        if (migrated !== undefined) {
+            if (migrated) {
+                loadedHf = true;
+            }
+            else {
+                loadedHf = false;
+            }
+        }
+        const hf = this.safeBool(params, 'hf', loadedHf);
+        params = this.omit(params, 'hf');
+        return [hf, params];
+    }
     async fetchCurrencies(params = {}) {
         /**
          * @method
@@ -2092,7 +2118,8 @@ export default class kucoin extends Exchange {
         const market = this.market(symbol);
         const testOrder = this.safeBool(params, 'test', false);
         params = this.omit(params, 'test');
-        const isHf = this.safeBool(params, 'hf', false);
+        let hf = undefined;
+        [hf, params] = await this.handleHfAndParams(params);
         const [triggerPrice, stopLossPrice, takeProfitPrice] = this.handleTriggerPrices(params);
         const tradeType = this.safeString(params, 'tradeType'); // keep it for backward compatibility
         const isTriggerOrder = (triggerPrice || stopLossPrice || takeProfitPrice);
@@ -2106,19 +2133,22 @@ export default class kucoin extends Exchange {
             if (isMarginOrder) {
                 response = await this.privatePostMarginOrderTest(orderRequest);
             }
+            else if (hf) {
+                response = await this.privatePostHfOrdersTest(orderRequest);
+            }
             else {
                 response = await this.privatePostOrdersTest(orderRequest);
             }
         }
-        else if (isHf) {
-            response = await this.privatePostHfOrders(orderRequest);
-        }
         else if (isTriggerOrder) {
             response = await this.privatePostStopOrder(orderRequest);
         }
         else if (isMarginOrder) {
             response = await this.privatePostMarginOrder(orderRequest);
         }
+        else if (hf) {
+            response = await this.privatePostHfOrders(orderRequest);
+        }
         else {
             response = await this.privatePostOrders(orderRequest);
         }
@@ -2219,8 +2249,8 @@ export default class kucoin extends Exchange {
             'symbol': market['id'],
             'orderList': ordersRequests,
         };
-        const hf = this.safeBool(params, 'hf', false);
-        params = this.omit(params, 'hf');
+        let hf = undefined;
+        [hf, params] = await this.handleHfAndParams(params);
         let response = undefined;
         if (hf) {
             response = await this.privatePostHfOrdersMulti(this.extend(request, params));
@@ -2409,7 +2439,8 @@ export default class kucoin extends Exchange {
         const request = {};
         const clientOrderId = this.safeString2(params, 'clientOid', 'clientOrderId');
         const stop = this.safeBool2(params, 'stop', 'trigger', false);
-        const hf = this.safeBool(params, 'hf', false);
+        let hf = undefined;
+        [hf, params] = await this.handleHfAndParams(params);
         if (hf) {
             if (symbol === undefined) {
                 throw new ArgumentsRequired(this.id + ' cancelOrder() requires a symbol parameter for hf orders');
@@ -2418,7 +2449,7 @@ export default class kucoin extends Exchange {
             request['symbol'] = market['id'];
         }
         let response = undefined;
-        params = this.omit(params, ['clientOid', 'clientOrderId', 'stop', 'hf', 'trigger']);
+        params = this.omit(params, ['clientOid', 'clientOrderId', 'stop', 'trigger']);
         if (clientOrderId !== undefined) {
             request['clientOid'] = clientOrderId;
             if (stop) {
@@ -2522,8 +2553,9 @@ export default class kucoin extends Exchange {
         await this.loadMarkets();
         const request = {};
         const stop = this.safeBool(params, 'stop', false);
-        const hf = this.safeBool(params, 'hf', false);
-        params = this.omit(params, ['stop', 'hf']);
+        let hf = undefined;
+        [hf, params] = await this.handleHfAndParams(params);
+        params = this.omit(params, 'stop');
         const [marginMode, query] = this.handleMarginModeAndParams('cancelAllOrders', params);
         if (symbol !== undefined) {
             request['symbol'] = this.marketId(symbol);
@@ -2580,8 +2612,12 @@ export default class kucoin extends Exchange {
         let lowercaseStatus = status.toLowerCase();
         const until = this.safeInteger(params, 'until');
         const stop = this.safeBool2(params, 'stop', 'trigger', false);
-        const hf = this.safeBool(params, 'hf', false);
-        params = this.omit(params, ['stop', 'hf', 'until', 'trigger']);
+        let hf = undefined;
+        [hf, params] = await this.handleHfAndParams(params);
+        if (hf && (symbol === undefined)) {
+            throw new ArgumentsRequired(this.id + ' fetchOrdersByStatus() requires a symbol parameter for hf orders');
+        }
+        params = this.omit(params, ['stop', 'trigger', 'till', 'until']);
         const [marginMode, query] = this.handleMarginModeAndParams('fetchOrdersByStatus', params);
         if (lowercaseStatus === 'open') {
             lowercaseStatus = 'active';
@@ -2759,7 +2795,8 @@ export default class kucoin extends Exchange {
         const request = {};
         const clientOrderId = this.safeString2(params, 'clientOid', 'clientOrderId');
         const stop = this.safeBool2(params, 'stop', 'trigger', false);
-        const hf = this.safeBool(params, 'hf', false);
+        let hf = undefined;
+        [hf, params] = await this.handleHfAndParams(params);
         let market = undefined;
         if (symbol !== undefined) {
             market = this.market(symbol);
@@ -2770,7 +2807,7 @@ export default class kucoin extends Exchange {
             }
             request['symbol'] = market['id'];
         }
-        params = this.omit(params, ['stop', 'hf', 'clientOid', 'clientOrderId', 'trigger']);
+        params = this.omit(params, ['stop', 'clientOid', 'clientOrderId', 'trigger']);
         let response = undefined;
         if (clientOrderId !== undefined) {
             request['clientOid'] = clientOrderId;
@@ -3036,7 +3073,8 @@ export default class kucoin extends Exchange {
             return await this.fetchPaginatedCallDynamic('fetchMyTrades', symbol, since, limit, params);
         }
         let request = {};
-        const hf = this.safeBool(params, 'hf', false);
+        let hf = undefined;
+        [hf, params] = await this.handleHfAndParams(params);
         if (hf && symbol === undefined) {
             throw new ArgumentsRequired(this.id + ' fetchMyTrades() requires a symbol parameter for hf orders');
         }
@@ -3763,11 +3801,11 @@ export default class kucoin extends Exchange {
         const accountsByType = this.safeDict(this.options, 'accountsByType');
         let type = this.safeString(accountsByType, requestedType, requestedType);
         params = this.omit(params, 'type');
-        const isHf = this.safeBool(params, 'hf', false);
-        if (isHf) {
+        let hf = undefined;
+        [hf, params] = await this.handleHfAndParams(params);
+        if (hf) {
             type = 'trade_hf';
         }
-        params = this.omit(params, 'hf');
         const [marginMode, query] = this.handleMarginModeAndParams('fetchBalance', params);
         let response = undefined;
         const request = {};
@@ -4223,8 +4261,8 @@ export default class kucoin extends Exchange {
         await this.loadAccounts();
         let paginate = false;
         [paginate, params] = this.handleOptionAndParams(params, 'fetchLedger', 'paginate');
-        const isHf = this.safeBool(params, 'hf');
-        params = this.omit(params, 'hf');
+        let hf = undefined;
+        [hf, params] = await this.handleHfAndParams(params);
         if (paginate) {
             return await this.fetchPaginatedCallDynamic('fetchLedger', code, since, limit, params);
         }
@@ -4248,7 +4286,7 @@ export default class kucoin extends Exchange {
         let marginMode = undefined;
         [marginMode, params] = this.handleMarginModeAndParams('fetchLedger', params);
         let response = undefined;
-        if (isHf) {
+        if (hf) {
             if (marginMode !== undefined) {
                 response = await this.privateGetHfMarginAccountLedgers(this.extend(request, params));
             }

package/js/src/kucoinfutures.d.ts

@@ -28,6 +28,7 @@ export default class kucoinfutures extends kucoin {
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
     fetchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     parseTicker(ticker: Dict, market?: Market): Ticker;
+    fetchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
     fetchFundingHistory(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<FundingHistory[]>;
     fetchPosition(symbol: string, params?: {}): Promise<import("./base/types.js").Position>;
     fetchPositions(symbols?: Strings, params?: {}): Promise<import("./base/types.js").Position[]>;

package/js/src/kucoinfutures.js

@@ -51,6 +51,7 @@ export default class kucoinfutures extends kucoin {
                 'createTriggerOrder': true,
                 'fetchAccounts': true,
                 'fetchBalance': true,
+                'fetchBidsAsks': true,
                 'fetchBorrowRateHistories': false,
                 'fetchBorrowRateHistory': false,
                 'fetchClosedOrders': true,
@@ -775,11 +776,20 @@ export default class kucoinfutures extends kucoin {
          * @see https://www.kucoin.com/docs/rest/futures-trading/market-data/get-symbols-list
          * @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
+         * @param {string} [params.method] the method to use, futuresPublicGetAllTickers or futuresPublicGetContractsActive
          * @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
         await this.loadMarkets();
         symbols = this.marketSymbols(symbols);
-        const response = await this.futuresPublicGetContractsActive(params);
+        let method = undefined;
+        [method, params] = this.handleOptionAndParams(params, 'fetchTickers', 'method', 'futuresPublicGetContractsActive');
+        let response = undefined;
+        if (method === 'futuresPublicGetAllTickers') {
+            response = await this.futuresPublicGetAllTickers(params);
+        }
+        else {
+            response = await this.futuresPublicGetContractsActive(params);
+        }
         //
         //    {
         //        "code": "200000",
@@ -842,7 +852,7 @@ export default class kucoinfutures extends kucoin {
         //        }
         //    }
         //
-        const data = this.safeList(response, 'data', []);
+        const data = this.safeList(response, 'data');
         const tickers = this.parseTickers(data, symbols);
         return this.filterByArrayTickers(tickers, 'symbol', symbols);
     }
@@ -952,6 +962,20 @@ export default class kucoinfutures extends kucoin {
             'info': ticker,
         }, market);
     }
+    async fetchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#fetchBidsAsks
+         * @description fetches the bid and ask price and volume for multiple markets
+         * @param {string[]} [symbols] unified symbols of the markets to fetch the bids and asks for, all markets 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}
+         */
+        const request = {
+            'method': 'futuresPublicGetAllTickers',
+        };
+        return await this.fetchTickers(symbols, this.extend(request, params));
+    }
     async fetchFundingHistory(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method

package/js/src/latoken.js

@@ -1544,6 +1544,7 @@ export default class latoken extends Exchange {
         const statuses = {
             'TRANSACTION_STATUS_CONFIRMED': 'ok',
             'TRANSACTION_STATUS_EXECUTED': 'ok',
+            'TRANSACTION_STATUS_CHECKING': 'pending',
             'TRANSACTION_STATUS_CANCELLED': 'canceled',
         };
         return this.safeString(statuses, status, status);

package/js/src/okx.d.ts

@@ -16,7 +16,6 @@ export default class okx extends Exchange {
     fetchMarkets(params?: {}): Promise<Market[]>;
     parseMarket(market: Dict): Market;
     fetchMarketsByType(type: any, params?: {}): Promise<MarketInterface[]>;
-    safeNetwork(networkId: any): string;
     fetchCurrencies(params?: {}): Promise<Currencies>;
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     parseTicker(ticker: Dict, market?: Market): Ticker;

package/js/src/okx.js

@@ -1041,6 +1041,7 @@ export default class okx extends Exchange {
                     'ZEC': 'Zcash',
                     'ZIL': 'Zilliqa',
                     'ZKSYNC': 'ZKSYNC',
+                    'OMNI': 'Omni',
                     // 'NEON3': 'N3', // tbd
                     // undetermined : "CELO-TOKEN", "Digital Cash", Khala
                     // todo: uncomment below after consensus
@@ -1595,14 +1596,6 @@ export default class okx extends Exchange {
         const dataResponse = this.safeList(response, 'data', []);
         return this.parseMarkets(dataResponse);
     }
-    safeNetwork(networkId) {
-        const networksById = {
-            'Bitcoin': 'BTC',
-            'Omni': 'OMNI',
-            'TRON': 'TRC20',
-        };
-        return this.safeString(networksById, networkId, networkId);
-    }
     async fetchCurrencies(params = {}) {
         /**
          * @method

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

@@ -1,5 +1,5 @@
 import binanceRest from '../binance.js';
-import type { Int, OrderSide, OrderType, Str, Strings, Trade, OrderBook, Order, Ticker, Tickers, OHLCV, Position, Balances, Num, Liquidation } from '../base/types.js';
+import type { Int, OrderSide, OrderType, Str, Strings, Trade, OrderBook, Order, Ticker, Tickers, OHLCV, Position, Balances, Num, Dict, Liquidation } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class binance extends binanceRest {
     describe(): any;
@@ -14,6 +14,8 @@ export default class binance extends binanceRest {
     handleMyLiquidation(client: Client, message: any): void;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
+    unWatchOrderBookForSymbols(symbols: string[], params?: {}): Promise<any>;
+    unWatchOrderBook(symbol: string, params?: {}): Promise<any>;
     fetchOrderBookWs(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleFetchOrderBook(client: Client, message: any): void;
     fetchOrderBookSnapshot(client: any, message: any, subscription: any): Promise<void>;
@@ -23,7 +25,11 @@ export default class binance extends binanceRest {
     handleOrderBook(client: Client, message: any): void;
     handleOrderBookSubscription(client: Client, message: any, subscription: any): void;
     handleSubscriptionStatus(client: Client, message: any): any;
+    handleUnSubscription(client: Client, subscription: Dict): void;
+    cleanCache(subscription: Dict): void;
     watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    unWatchTradesForSymbols(symbols: string[], params?: {}): Promise<any>;
+    unWatchTrades(symbol: string, params?: {}): Promise<any>;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     parseWsTrade(trade: any, market?: any): Trade;
     handleTrade(client: Client, message: any): void;
@@ -35,6 +41,8 @@ export default class binance extends binanceRest {
     handleFetchOHLCV(client: Client, message: any): void;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    unWatchTickers(symbols?: Strings, params?: {}): Promise<any>;
+    unWatchTicker(symbol: string, params?: {}): Promise<any>;
     watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
     watchMultiTickerHelper(methodName: any, channelName: string, symbols?: Strings, params?: {}): Promise<any>;
     parseWsTicker(message: any, marketType: any): Ticker;