ccxt 4.3.95 → 4.3.96

package/js/src/pro/okx.js

@@ -17,6 +17,7 @@ export default class okx extends okxRest {
                 'ws': true,
                 'watchTicker': true,
                 'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchOrderBook': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': true,
@@ -128,9 +129,8 @@ export default class okx extends okxRest {
         }
         symbols = this.marketSymbols(symbols);
         const url = this.getUrl(channel, access);
-        let messageHash = channel;
+        const messageHashes = [];
         const args = [];
-        messageHash += '::' + symbols.join(',');
         for (let i = 0; i < symbols.length; i++) {
             const marketId = this.marketId(symbols[i]);
             const arg = {
@@ -138,12 +138,13 @@ export default class okx extends okxRest {
                 'instId': marketId,
             };
             args.push(this.extend(arg, params));
+            messageHashes.push(channel + '::' + symbols[i]);
         }
         const request = {
             'op': 'subscribe',
             'args': args,
         };
-        return await this.watch(url, messageHash, request, messageHash);
+        return await this.watchMultiple(url, messageHashes, request, messageHashes);
     }
     async subscribe(access, messageHash, channel, symbol, params = {}) {
         await this.loadMarkets();
@@ -397,6 +398,19 @@ export default class okx extends okxRest {
         const ticker = await this.watchTickers([symbol], params);
         return this.safeValue(ticker, symbol);
     }
+    async unWatchTicker(symbol, params = {}) {
+        /**
+         * @method
+         * @name okx#unWatchTicker
+         * @see https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
+         * @description unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours 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 {string} [params.channel] the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        return await this.unWatchTickers([symbol], params);
+    }
     async watchTickers(symbols = undefined, params = {}) {
         /**
          * @method
@@ -418,6 +432,40 @@ export default class okx extends okxRest {
         }
         return this.filterByArray(this.tickers, 'symbol', symbols);
     }
+    async unWatchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name okx#unWatchTickers
+         * @see https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
+         * @description unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+         * @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 {string} [params.channel] the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        let channel = undefined;
+        [channel, params] = this.handleOptionAndParams(params, 'watchTickers', 'channel', 'tickers');
+        const topics = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            messageHashes.push('unsubscribe:ticker:' + symbol);
+            const marketId = this.marketId(symbol);
+            const topic = {
+                'channel': channel,
+                'instId': marketId,
+            };
+            topics.push(topic);
+        }
+        const request = {
+            'op': 'unsubscribe',
+            'args': topics,
+        };
+        const url = this.getUrl(channel, 'public');
+        return await this.watchMultiple(url, messageHashes, request, messageHashes);
+    }
     handleTicker(client, message) {
         //
         //     {
@@ -444,30 +492,109 @@ export default class okx extends okxRest {
         //         ]
         //     }
         //
+        this.handleBidAsk(client, message);
         const arg = this.safeValue(message, 'arg', {});
+        const marketId = this.safeString(arg, 'instId');
+        const market = this.safeMarket(marketId, undefined, '-');
+        const symbol = market['symbol'];
         const channel = this.safeString(arg, 'channel');
         const data = this.safeValue(message, 'data', []);
-        const newTickers = [];
+        const newTickers = {};
         for (let i = 0; i < data.length; i++) {
             const ticker = this.parseTicker(data[i]);
-            const symbol = ticker['symbol'];
             this.tickers[symbol] = ticker;
-            newTickers.push(ticker);
-        }
-        const messageHashes = this.findMessageHashes(client, channel + '::');
-        for (let i = 0; i < messageHashes.length; i++) {
-            const messageHash = messageHashes[i];
-            const parts = messageHash.split('::');
-            const symbolsString = parts[1];
-            const symbols = symbolsString.split(',');
-            const tickers = this.filterByArray(newTickers, 'symbol', symbols);
-            const tickersSymbols = Object.keys(tickers);
-            const numTickers = tickersSymbols.length;
-            if (numTickers > 0) {
-                client.resolve(tickers, messageHash);
-            }
+            newTickers[symbol] = ticker;
         }
-        return message;
+        const messageHash = channel + '::' + symbol;
+        client.resolve(newTickers, messageHash);
+    }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name okx#watchBidsAsks
+         * @see https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
+         * @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);
+        let channel = undefined;
+        [channel, params] = this.handleOptionAndParams(params, 'watchBidsAsks', 'channel', 'tickers');
+        const url = this.getUrl(channel, 'public');
+        const messageHashes = [];
+        const args = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const marketId = this.marketId(symbols[i]);
+            const arg = {
+                'channel': channel,
+                'instId': marketId,
+            };
+            args.push(this.extend(arg, params));
+            messageHashes.push('bidask::' + symbols[i]);
+        }
+        const request = {
+            'op': 'subscribe',
+            'args': args,
+        };
+        const newTickers = await this.watchMultiple(url, messageHashes, request, messageHashes);
+        if (this.newUpdates) {
+            const tickers = {};
+            tickers[newTickers['symbol']] = newTickers;
+            return tickers;
+        }
+        return this.filterByArray(this.bidsasks, 'symbol', symbols);
+    }
+    handleBidAsk(client, message) {
+        //
+        //     {
+        //         "arg": { channel: "tickers", instId: "BTC-USDT" },
+        //         "data": [
+        //             {
+        //                 "instType": "SPOT",
+        //                 "instId": "BTC-USDT",
+        //                 "last": "31500.1",
+        //                 "lastSz": "0.00001754",
+        //                 "askPx": "31500.1",
+        //                 "askSz": "0.00998144",
+        //                 "bidPx": "31500",
+        //                 "bidSz": "3.05652439",
+        //                 "open24h": "31697",
+        //                 "high24h": "32248",
+        //                 "low24h": "31165.6",
+        //                 "sodUtc0": "31385.5",
+        //                 "sodUtc8": "32134.9",
+        //                 "volCcy24h": "503403597.38138519",
+        //                 "vol24h": "15937.10781721",
+        //                 "ts": "1626526618762"
+        //             }
+        //         ]
+        //     }
+        //
+        const data = this.safeList(message, 'data', []);
+        const ticker = this.safeDict(data, 0, {});
+        const parsedTicker = this.parseWsBidAsk(ticker);
+        const symbol = parsedTicker['symbol'];
+        this.bidsasks[symbol] = parsedTicker;
+        const messageHash = 'bidask::' + symbol;
+        client.resolve(parsedTicker, messageHash);
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const marketId = this.safeString(ticker, 'instId');
+        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, 'askPx'),
+            'askVolume': this.safeString(ticker, 'askSz'),
+            'bid': this.safeString(ticker, 'bidPx'),
+            'bidVolume': this.safeString(ticker, 'bidSz'),
+            'info': ticker,
+        }, market);
     }
     async watchLiquidationsForSymbols(symbols = undefined, since = undefined, limit = undefined, params = {}) {
         /**
@@ -582,12 +709,28 @@ export default class okx extends okxRest {
         params = this.omit(params, ['stop', 'trigger']);
         await this.authenticate({ 'access': isStop ? 'business' : 'private' });
         symbols = this.marketSymbols(symbols, undefined, true, true);
-        let messageHash = 'myLiquidations';
+        const messageHash = 'myLiquidations';
+        const messageHashes = [];
         if (symbols !== undefined) {
-            messageHash += '::' + symbols.join(',');
+            for (let i = 0; i < symbols.length; i++) {
+                const symbol = symbols[i];
+                messageHashes.push(messageHash + '::' + symbol);
+            }
+        }
+        else {
+            messageHashes.push(messageHash);
         }
         const channel = 'balance_and_position';
-        const newLiquidations = await this.subscribe('private', messageHash, channel, undefined, params);
+        const request = {
+            'op': 'subscribe',
+            'args': [
+                {
+                    'channel': channel,
+                },
+            ],
+        };
+        const url = this.getUrl(channel, 'private');
+        const newLiquidations = await this.watchMultiple(url, messageHashes, this.deepExtend(request, params), messageHashes);
         if (this.newUpdates) {
             return newLiquidations;
         }
@@ -754,6 +897,19 @@ export default class okx extends okxRest {
         }
         return this.filterBySinceLimit(ohlcv, since, limit, 0, true);
     }
+    async unWatchOHLCV(symbol, timeframe = '1m', params = {}) {
+        /**
+         * @method
+         * @name okx#unWatchOHLCV
+         * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @param {string} symbol unified symbol of the market to fetch OHLCV data for
+         * @param {string} timeframe the length of time each candle represents
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         */
+        await this.loadMarkets();
+        return await this.unWatchOHLCVForSymbols([[symbol, timeframe]], params);
+    }
     async watchOHLCVForSymbols(symbolsAndTimeframes, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -798,6 +954,43 @@ export default class okx extends okxRest {
         const filtered = this.filterBySinceLimit(candles, since, limit, 0, true);
         return this.createOHLCVObject(symbol, timeframe, filtered);
     }
+    async unWatchOHLCVForSymbols(symbolsAndTimeframes, params = {}) {
+        /**
+         * @method
+         * @name okx#unWatchOHLCVForSymbols
+         * @description unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @param {string[][]} symbolsAndTimeframes array of arrays containing unified symbols and timeframes to fetch OHLCV data for, example [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         */
+        const symbolsLength = symbolsAndTimeframes.length;
+        if (symbolsLength === 0 || !Array.isArray(symbolsAndTimeframes[0])) {
+            throw new ArgumentsRequired(this.id + " watchOHLCVForSymbols() requires a an array of symbols and timeframes, like  [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]");
+        }
+        await this.loadMarkets();
+        const topics = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbolsAndTimeframes.length; i++) {
+            const symbolAndTimeframe = symbolsAndTimeframes[i];
+            const sym = symbolAndTimeframe[0];
+            const tf = symbolAndTimeframe[1];
+            const marketId = this.marketId(sym);
+            const interval = this.safeString(this.timeframes, tf, tf);
+            const channel = 'candle' + interval;
+            const topic = {
+                'channel': channel,
+                'instId': marketId,
+            };
+            topics.push(topic);
+            messageHashes.push('unsubscribe:multi:' + channel + ':' + sym);
+        }
+        const request = {
+            'op': 'unsubscribe',
+            'args': topics,
+        };
+        const url = this.getUrl('candle', 'public');
+        return await this.watchMultiple(url, messageHashes, request, messageHashes);
+    }
     handleOHLCV(client, message) {
         //
         //     {
@@ -1507,6 +1700,9 @@ export default class okx extends okxRest {
         //    }
         //
         const arg = this.safeValue(message, 'arg', {});
+        const marketId = this.safeString(arg, 'instId');
+        const market = this.safeMarket(marketId, undefined, '-');
+        const symbol = market['symbol'];
         const channel = this.safeString(arg, 'channel', '');
         const data = this.safeValue(message, 'data', []);
         if (this.positions === undefined) {
@@ -1527,18 +1723,11 @@ export default class okx extends okxRest {
             newPositions.push(position);
             cache.append(position);
         }
-        const messageHashes = this.findMessageHashes(client, channel + '::');
-        for (let i = 0; i < messageHashes.length; i++) {
-            const messageHash = messageHashes[i];
-            const parts = messageHash.split('::');
-            const symbolsString = parts[1];
-            const symbols = symbolsString.split(',');
-            const positions = this.filterByArray(newPositions, 'symbol', symbols, false);
-            if (!this.isEmpty(positions)) {
-                client.resolve(positions, messageHash);
-            }
+        let messageHash = channel;
+        if (symbol !== undefined) {
+            messageHash = channel + '::' + symbol;
         }
-        client.resolve(newPositions, channel);
+        client.resolve(newPositions, messageHash);
     }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
@@ -2172,6 +2361,40 @@ export default class okx extends okxRest {
         client.reject(error, subMessageHash);
         client.resolve(true, messageHash);
     }
+    handleUnsubscriptionOHLCV(client, symbol, channel) {
+        const tf = channel.replace('candle', '');
+        const timeframe = this.findTimeframe(tf);
+        const subMessageHash = 'multi:' + channel + ':' + symbol;
+        const messageHash = 'unsubscribe:' + subMessageHash;
+        if (subMessageHash in client.subscriptions) {
+            delete client.subscriptions[subMessageHash];
+        }
+        if (messageHash in client.subscriptions) {
+            delete client.subscriptions[messageHash];
+        }
+        if (timeframe in this.ohlcvs[symbol]) {
+            delete this.ohlcvs[symbol][timeframe];
+        }
+        const error = new UnsubscribeError(this.id + ' ' + subMessageHash);
+        client.reject(error, subMessageHash);
+        client.resolve(true, messageHash);
+    }
+    handleUnsubscriptionTicker(client, symbol, channel) {
+        const subMessageHash = channel + '::' + symbol;
+        const messageHash = 'unsubscribe:ticker:' + symbol;
+        if (subMessageHash in client.subscriptions) {
+            delete client.subscriptions[subMessageHash];
+        }
+        if (messageHash in client.subscriptions) {
+            delete client.subscriptions[messageHash];
+        }
+        if (symbol in this.tickers) {
+            delete this.tickers[symbol];
+        }
+        const error = new UnsubscribeError(this.id + ' ' + subMessageHash);
+        client.reject(error, subMessageHash);
+        client.resolve(true, messageHash);
+    }
     handleUnsubscription(client, message) {
         //
         // {
@@ -2184,7 +2407,7 @@ export default class okx extends okxRest {
         // }
         // arg might be an array or list
         const arg = this.safeDict(message, 'arg', {});
-        const channel = this.safeString(arg, 'channel');
+        const channel = this.safeString(arg, 'channel', '');
         const marketId = this.safeString(arg, 'instId');
         const symbol = this.safeSymbol(marketId);
         if (channel === 'trades') {
@@ -2193,5 +2416,11 @@ export default class okx extends okxRest {
         else if (channel.startsWith('bbo') || channel.startsWith('book')) {
             this.handleUnsubscriptionOrderBook(client, symbol, channel);
         }
+        else if (channel.indexOf('tickers') > -1) {
+            this.handleUnsubscriptionTicker(client, symbol, channel);
+        }
+        else if (channel.startsWith('candle')) {
+            this.handleUnsubscriptionOHLCV(client, symbol, channel);
+        }
     }
 }

package/js/src/tradeogre.js

@@ -80,7 +80,6 @@ export default class tradeogre extends Exchange {
                 'fetchOrderBooks': false,
                 'fetchOrders': false,
                 'fetchOrderTrades': false,
-                'fetchPermissions': false,
                 'fetchPosition': false,
                 'fetchPositionHistory': false,
                 'fetchPositionMode': false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.3.95",
+  "version": "4.3.96",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges",
   "unpkg": "dist/ccxt.browser.min.js",
   "type": "module",

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

@@ -1,56 +0,0 @@
-import { implicitReturnType } from '../base/types.js';
-import _zonda from '../zonda.js';
-interface zonda {
-    publicGetIdAll(params?: {}): Promise<implicitReturnType>;
-    publicGetIdMarket(params?: {}): Promise<implicitReturnType>;
-    publicGetIdOrderbook(params?: {}): Promise<implicitReturnType>;
-    publicGetIdTicker(params?: {}): Promise<implicitReturnType>;
-    publicGetIdTrades(params?: {}): Promise<implicitReturnType>;
-    privatePostInfo(params?: {}): Promise<implicitReturnType>;
-    privatePostTrade(params?: {}): Promise<implicitReturnType>;
-    privatePostCancel(params?: {}): Promise<implicitReturnType>;
-    privatePostOrderbook(params?: {}): Promise<implicitReturnType>;
-    privatePostOrders(params?: {}): Promise<implicitReturnType>;
-    privatePostTransfer(params?: {}): Promise<implicitReturnType>;
-    privatePostWithdraw(params?: {}): Promise<implicitReturnType>;
-    privatePostHistory(params?: {}): Promise<implicitReturnType>;
-    privatePostTransactions(params?: {}): Promise<implicitReturnType>;
-    v1_01PublicGetTradingTicker(params?: {}): Promise<implicitReturnType>;
-    v1_01PublicGetTradingTickerSymbol(params?: {}): Promise<implicitReturnType>;
-    v1_01PublicGetTradingStats(params?: {}): Promise<implicitReturnType>;
-    v1_01PublicGetTradingStatsSymbol(params?: {}): Promise<implicitReturnType>;
-    v1_01PublicGetTradingOrderbookSymbol(params?: {}): Promise<implicitReturnType>;
-    v1_01PublicGetTradingTransactionsSymbol(params?: {}): Promise<implicitReturnType>;
-    v1_01PublicGetTradingCandleHistorySymbolResolution(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetApiPaymentsDepositsCryptoAddresses(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetPaymentsWithdrawalDetailId(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetPaymentsDepositDetailId(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetTradingOffer(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetTradingStopOffer(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetTradingConfigSymbol(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetTradingHistoryTransactions(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetBalancesBITBAYHistory(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetBalancesBITBAYBalance(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetFiatCantorRateBaseIdQuoteId(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetFiatCantorHistory(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetClientPaymentsV2CustomerCryptoCurrencyChannelsDeposit(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetClientPaymentsV2CustomerCryptoCurrencyChannelsWithdrawal(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetClientPaymentsV2CustomerCryptoDepositFee(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateGetClientPaymentsV2CustomerCryptoWithdrawalFee(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivatePostTradingOfferSymbol(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivatePostTradingStopOfferSymbol(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivatePostTradingConfigSymbol(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivatePostBalancesBITBAYBalance(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivatePostBalancesBITBAYBalanceTransferSourceDestination(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivatePostFiatCantorExchange(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivatePostApiPaymentsWithdrawalsCrypto(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivatePostApiPaymentsWithdrawalsFiat(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivatePostClientPaymentsV2CustomerCryptoDeposit(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivatePostClientPaymentsV2CustomerCryptoWithdrawal(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateDeleteTradingOfferSymbolIdSidePrice(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivateDeleteTradingStopOfferSymbolIdSidePrice(params?: {}): Promise<implicitReturnType>;
-    v1_01PrivatePutBalancesBITBAYBalanceId(params?: {}): Promise<implicitReturnType>;
-}
-declare abstract class zonda extends _zonda {
-}
-export default zonda;

package/js/src/abstract/bitbay.js

@@ -1,11 +0,0 @@
-// ----------------------------------------------------------------------------
-
-// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
-// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
-// EDIT THE CORRESPONDENT .ts FILE INSTEAD
-
-// -------------------------------------------------------------------------------
-import _zonda from '../zonda.js';
-class zonda extends _zonda {
-}
-export default zonda;

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

@@ -1,118 +0,0 @@
-import { implicitReturnType } from '../base/types.js';
-import _hitbtc from '../hitbtc.js';
-interface hitbtc {
-    publicGetPublicCurrency(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicCurrencyCurrency(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicSymbolSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicTicker(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicTickerSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicPriceRate(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicPriceHistory(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicPriceTicker(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicPriceTickerSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicTrades(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicTradesSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicOrderbook(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicOrderbookSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicCandles(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicCandlesSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicConvertedCandles(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicConvertedCandlesSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesInfo(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesInfoSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesHistoryFunding(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesHistoryFundingSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesCandlesIndexPrice(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesCandlesIndexPriceSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesCandlesMarkPrice(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesCandlesMarkPriceSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesCandlesPremiumIndex(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesCandlesPremiumIndexSymbol(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesCandlesOpenInterest(params?: {}): Promise<implicitReturnType>;
-    publicGetPublicFuturesCandlesOpenInterestSymbol(params?: {}): Promise<implicitReturnType>;
-    privateGetSpotBalance(params?: {}): Promise<implicitReturnType>;
-    privateGetSpotBalanceCurrency(params?: {}): Promise<implicitReturnType>;
-    privateGetSpotOrder(params?: {}): Promise<implicitReturnType>;
-    privateGetSpotOrderClientOrderId(params?: {}): Promise<implicitReturnType>;
-    privateGetSpotFee(params?: {}): Promise<implicitReturnType>;
-    privateGetSpotFeeSymbol(params?: {}): Promise<implicitReturnType>;
-    privateGetSpotHistoryOrder(params?: {}): Promise<implicitReturnType>;
-    privateGetSpotHistoryTrade(params?: {}): Promise<implicitReturnType>;
-    privateGetMarginAccount(params?: {}): Promise<implicitReturnType>;
-    privateGetMarginAccountIsolatedSymbol(params?: {}): Promise<implicitReturnType>;
-    privateGetMarginAccountCrossCurrency(params?: {}): Promise<implicitReturnType>;
-    privateGetMarginOrder(params?: {}): Promise<implicitReturnType>;
-    privateGetMarginOrderClientOrderId(params?: {}): Promise<implicitReturnType>;
-    privateGetMarginConfig(params?: {}): Promise<implicitReturnType>;
-    privateGetMarginHistoryOrder(params?: {}): Promise<implicitReturnType>;
-    privateGetMarginHistoryTrade(params?: {}): Promise<implicitReturnType>;
-    privateGetMarginHistoryPositions(params?: {}): Promise<implicitReturnType>;
-    privateGetMarginHistoryClearing(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesBalance(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesBalanceCurrency(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesAccount(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesAccountIsolatedSymbol(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesOrder(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesOrderClientOrderId(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesConfig(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesFee(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesFeeSymbol(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesHistoryOrder(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesHistoryTrade(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesHistoryPositions(params?: {}): Promise<implicitReturnType>;
-    privateGetFuturesHistoryClearing(params?: {}): Promise<implicitReturnType>;
-    privateGetWalletBalance(params?: {}): Promise<implicitReturnType>;
-    privateGetWalletBalanceCurrency(params?: {}): Promise<implicitReturnType>;
-    privateGetWalletCryptoAddress(params?: {}): Promise<implicitReturnType>;
-    privateGetWalletCryptoAddressRecentDeposit(params?: {}): Promise<implicitReturnType>;
-    privateGetWalletCryptoAddressRecentWithdraw(params?: {}): Promise<implicitReturnType>;
-    privateGetWalletCryptoAddressCheckMine(params?: {}): Promise<implicitReturnType>;
-    privateGetWalletTransactions(params?: {}): Promise<implicitReturnType>;
-    privateGetWalletTransactionsTxId(params?: {}): Promise<implicitReturnType>;
-    privateGetWalletCryptoFeeEstimate(params?: {}): Promise<implicitReturnType>;
-    privateGetWalletAirdrops(params?: {}): Promise<implicitReturnType>;
-    privateGetWalletAmountLocks(params?: {}): Promise<implicitReturnType>;
-    privateGetSubAccount(params?: {}): Promise<implicitReturnType>;
-    privateGetSubAccountAcl(params?: {}): Promise<implicitReturnType>;
-    privateGetSubAccountBalanceSubAccID(params?: {}): Promise<implicitReturnType>;
-    privateGetSubAccountCryptoAddressSubAccIDCurrency(params?: {}): Promise<implicitReturnType>;
-    privatePostSpotOrder(params?: {}): Promise<implicitReturnType>;
-    privatePostSpotOrderList(params?: {}): Promise<implicitReturnType>;
-    privatePostMarginOrder(params?: {}): Promise<implicitReturnType>;
-    privatePostMarginOrderList(params?: {}): Promise<implicitReturnType>;
-    privatePostFuturesOrder(params?: {}): Promise<implicitReturnType>;
-    privatePostFuturesOrderList(params?: {}): Promise<implicitReturnType>;
-    privatePostWalletCryptoAddress(params?: {}): Promise<implicitReturnType>;
-    privatePostWalletCryptoWithdraw(params?: {}): Promise<implicitReturnType>;
-    privatePostWalletConvert(params?: {}): Promise<implicitReturnType>;
-    privatePostWalletTransfer(params?: {}): Promise<implicitReturnType>;
-    privatePostWalletInternalWithdraw(params?: {}): Promise<implicitReturnType>;
-    privatePostWalletCryptoCheckOffchainAvailable(params?: {}): Promise<implicitReturnType>;
-    privatePostWalletCryptoFeesEstimate(params?: {}): Promise<implicitReturnType>;
-    privatePostWalletAirdropsIdClaim(params?: {}): Promise<implicitReturnType>;
-    privatePostSubAccountFreeze(params?: {}): Promise<implicitReturnType>;
-    privatePostSubAccountActivate(params?: {}): Promise<implicitReturnType>;
-    privatePostSubAccountTransfer(params?: {}): Promise<implicitReturnType>;
-    privatePostSubAccountAcl(params?: {}): Promise<implicitReturnType>;
-    privatePatchSpotOrderClientOrderId(params?: {}): Promise<implicitReturnType>;
-    privatePatchMarginOrderClientOrderId(params?: {}): Promise<implicitReturnType>;
-    privatePatchFuturesOrderClientOrderId(params?: {}): Promise<implicitReturnType>;
-    privateDeleteSpotOrder(params?: {}): Promise<implicitReturnType>;
-    privateDeleteSpotOrderClientOrderId(params?: {}): Promise<implicitReturnType>;
-    privateDeleteMarginPosition(params?: {}): Promise<implicitReturnType>;
-    privateDeleteMarginPositionIsolatedSymbol(params?: {}): Promise<implicitReturnType>;
-    privateDeleteMarginOrder(params?: {}): Promise<implicitReturnType>;
-    privateDeleteMarginOrderClientOrderId(params?: {}): Promise<implicitReturnType>;
-    privateDeleteFuturesPosition(params?: {}): Promise<implicitReturnType>;
-    privateDeleteFuturesPositionMarginModeSymbol(params?: {}): Promise<implicitReturnType>;
-    privateDeleteFuturesOrder(params?: {}): Promise<implicitReturnType>;
-    privateDeleteFuturesOrderClientOrderId(params?: {}): Promise<implicitReturnType>;
-    privateDeleteWalletCryptoWithdrawId(params?: {}): Promise<implicitReturnType>;
-    privatePutMarginAccountIsolatedSymbol(params?: {}): Promise<implicitReturnType>;
-    privatePutFuturesAccountIsolatedSymbol(params?: {}): Promise<implicitReturnType>;
-    privatePutWalletCryptoWithdrawId(params?: {}): Promise<implicitReturnType>;
-}
-declare abstract class hitbtc extends _hitbtc {
-}
-export default hitbtc;

package/js/src/abstract/hitbtc3.js

@@ -1,11 +0,0 @@
-// ----------------------------------------------------------------------------
-
-// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
-// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
-// EDIT THE CORRESPONDENT .ts FILE INSTEAD
-
-// -------------------------------------------------------------------------------
-import _hitbtc from '../hitbtc.js';
-class hitbtc extends _hitbtc {
-}
-export default hitbtc;