ccxt 4.4.82 → 4.4.86

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

@@ -31,6 +31,12 @@ class mexc extends mexc$1 {
                 'watchBidsAsks': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': false,
+                'unWatchTicker': true,
+                'unWatchTickers': true,
+                'unWatchBidsAsks': true,
+                'unWatchOHLCV': true,
+                'unWatchOrderBook': true,
+                'unWatchTrades': true,
             },
             'urls': {
                 'api': {
@@ -488,12 +494,15 @@ class mexc extends mexc$1 {
         }, market);
     }
     async watchSpotPublic(channel, messageHash, params = {}) {
+        const unsubscribed = this.safeBool(params, 'unsubscribed', false);
+        params = this.omit(params, ['unsubscribed']);
         const url = this.urls['api']['ws']['spot'];
+        const method = (unsubscribed) ? 'UNSUBSCRIPTION' : 'SUBSCRIPTION';
         const request = {
-            'method': 'SUBSCRIPTION',
+            'method': method,
             'params': [channel],
         };
-        return await this.watch(url, messageHash, this.extend(request, params), channel);
+        return await this.watch(url, messageHash, this.extend(request, params), messageHash);
     }
     async watchSpotPrivate(channel, messageHash, params = {}) {
         this.checkRequiredCredentials();
@@ -785,11 +794,8 @@ class mexc extends mexc$1 {
         const messageHash = 'orderbook:' + symbol;
         const subscription = this.safeValue(client.subscriptions, messageHash);
         const limit = this.safeInteger(subscription, 'limit');
-        if (subscription === true) {
-            // we set client.subscriptions[messageHash] to 1
-            // once we have received the first delta and initialized the orderbook
-            client.subscriptions[messageHash] = 1;
-            this.orderbooks[symbol] = this.countedOrderBook({});
+        if (!(symbol in this.orderbooks)) {
+            this.orderbooks[symbol] = this.orderBook();
         }
         const storedOrderBook = this.orderbooks[symbol];
         const nonce = this.safeInteger(storedOrderBook, 'nonce');
@@ -1412,6 +1418,297 @@ class mexc extends mexc$1 {
         this.balance[type] = this.safeBalance(this.balance[type]);
         client.resolve(this.balance[type], messageHash);
     }
+    /**
+     * @method
+     * @name mexc#unWatchTicker
+     * @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} symbol 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}
+     */
+    async unWatchTicker(symbol, params = {}) {
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const messageHash = 'unsubscribe:ticker:' + market['symbol'];
+        let url = undefined;
+        let channel = undefined;
+        if (market['spot']) {
+            let miniTicker = false;
+            [miniTicker, params] = this.handleOptionAndParams(params, 'watchTicker', 'miniTicker');
+            if (miniTicker) {
+                channel = 'spot@public.miniTicker.v3.api@' + market['id'] + '@UTC+8';
+            }
+            else {
+                channel = 'spot@public.bookTicker.v3.api@' + market['id'];
+            }
+            url = this.urls['api']['ws']['spot'];
+            params['unsubscribed'] = true;
+            this.watchSpotPublic(channel, messageHash, params);
+        }
+        else {
+            channel = 'unsub.ticker';
+            const requestParams = {
+                'symbol': market['id'],
+            };
+            url = this.urls['api']['ws']['swap'];
+            this.watchSwapPublic(channel, messageHash, requestParams, params);
+        }
+        const client = this.client(url);
+        this.handleUnsubscriptions(client, [messageHash]);
+        return undefined;
+    }
+    /**
+     * @method
+     * @name mexc#unWatchTickers
+     * @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
+     * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+     */
+    async unWatchTickers(symbols = undefined, params = {}) {
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined);
+        const messageHashes = [];
+        const firstSymbol = this.safeString(symbols, 0);
+        let market = undefined;
+        if (firstSymbol !== undefined) {
+            market = this.market(firstSymbol);
+        }
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('watchTickers', market, params);
+        const isSpot = (type === 'spot');
+        const url = (isSpot) ? this.urls['api']['ws']['spot'] : this.urls['api']['ws']['swap'];
+        const request = {};
+        if (isSpot) {
+            let miniTicker = false;
+            [miniTicker, params] = this.handleOptionAndParams(params, 'watchTickers', 'miniTicker');
+            const topics = [];
+            if (!miniTicker) {
+                if (symbols === undefined) {
+                    throw new errors.ArgumentsRequired(this.id + ' watchTickers required symbols argument for the bookTicker channel');
+                }
+                const marketIds = this.marketIds(symbols);
+                for (let i = 0; i < marketIds.length; i++) {
+                    const marketId = marketIds[i];
+                    messageHashes.push('unsubscribe:ticker:' + symbols[i]);
+                    const channel = 'spot@public.bookTicker.v3.api@' + marketId;
+                    topics.push(channel);
+                }
+            }
+            else {
+                topics.push('spot@public.miniTickers.v3.api@UTC+8');
+                if (symbols === undefined) {
+                    messageHashes.push('unsubscribe:spot:ticker');
+                }
+                else {
+                    for (let i = 0; i < symbols.length; i++) {
+                        messageHashes.push('unsubscribe:ticker:' + symbols[i]);
+                    }
+                }
+            }
+            request['method'] = 'UNSUBSCRIPTION';
+            request['params'] = topics;
+        }
+        else {
+            request['method'] = 'unsub.tickers';
+            request['params'] = {};
+            messageHashes.push('unsubscribe:ticker');
+        }
+        const client = this.client(url);
+        this.watchMultiple(url, messageHashes, this.extend(request, params), messageHashes);
+        this.handleUnsubscriptions(client, messageHashes);
+        return undefined;
+    }
+    /**
+     * @method
+     * @name mexc#unWatchBidsAsks
+     * @description unWatches 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}
+     */
+    async unWatchBidsAsks(symbols = undefined, params = {}) {
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, true, false, true);
+        let marketType = undefined;
+        if (symbols === undefined) {
+            throw new errors.ArgumentsRequired(this.id + ' watchBidsAsks required symbols argument');
+        }
+        const markets = this.marketsForSymbols(symbols);
+        [marketType, params] = this.handleMarketTypeAndParams('watchBidsAsks', markets[0], params);
+        const isSpot = marketType === 'spot';
+        if (!isSpot) {
+            throw new errors.NotSupported(this.id + ' watchBidsAsks only support spot market');
+        }
+        const messageHashes = [];
+        const topics = [];
+        for (let i = 0; i < symbols.length; i++) {
+            if (isSpot) {
+                const market = this.market(symbols[i]);
+                topics.push('spot@public.bookTicker.v3.api@' + market['id']);
+            }
+            messageHashes.push('unsubscribe:bidask:' + symbols[i]);
+        }
+        const url = this.urls['api']['ws']['spot'];
+        const request = {
+            'method': 'UNSUBSCRIPTION',
+            'params': topics,
+        };
+        const client = this.client(url);
+        this.watchMultiple(url, messageHashes, this.extend(request, params), messageHashes);
+        this.handleUnsubscriptions(client, messageHashes);
+        return undefined;
+    }
+    /**
+     * @method
+     * @name mexc#unWatchOHLCV
+     * @description unWatches 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
+     * @param {object} [params.timezone] if provided, kline intervals are interpreted in that timezone instead of UTC, example '+08:00'
+     * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+     */
+    async unWatchOHLCV(symbol, timeframe = '1m', params = {}) {
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        symbol = market['symbol'];
+        const timeframes = this.safeValue(this.options, 'timeframes', {});
+        const timeframeId = this.safeString(timeframes, timeframe);
+        const messageHash = 'unsubscribe:candles:' + symbol + ':' + timeframe;
+        let url = undefined;
+        if (market['spot']) {
+            url = this.urls['api']['ws']['spot'];
+            const channel = 'spot@public.kline.v3.api@' + market['id'] + '@' + timeframeId;
+            params['unsubscribed'] = true;
+            this.watchSpotPublic(channel, messageHash, params);
+        }
+        else {
+            url = this.urls['api']['ws']['swap'];
+            const channel = 'unsub.kline';
+            const requestParams = {
+                'symbol': market['id'],
+                'interval': timeframeId,
+            };
+            this.watchSwapPublic(channel, messageHash, requestParams, params);
+        }
+        const client = this.client(url);
+        this.handleUnsubscriptions(client, [messageHash]);
+        return undefined;
+    }
+    /**
+     * @method
+     * @name mexc#unWatchOrderBook
+     * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+     * @param {string} symbol unified array of symbols
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+     */
+    async unWatchOrderBook(symbol, params = {}) {
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        symbol = market['symbol'];
+        const messageHash = 'unsubscribe:orderbook:' + symbol;
+        let url = undefined;
+        if (market['spot']) {
+            url = this.urls['api']['ws']['spot'];
+            const channel = 'spot@public.increase.depth.v3.api@' + market['id'];
+            params['unsubscribed'] = true;
+            this.watchSpotPublic(channel, messageHash, params);
+        }
+        else {
+            url = this.urls['api']['ws']['swap'];
+            const channel = 'unsub.depth';
+            const requestParams = {
+                'symbol': market['id'],
+            };
+            this.watchSwapPublic(channel, messageHash, requestParams, params);
+        }
+        const client = this.client(url);
+        this.handleUnsubscriptions(client, [messageHash]);
+        return undefined;
+    }
+    /**
+     * @method
+     * @name mexc#unWatchTrades
+     * @description unsubscribes from the trades channel
+     * @param {string} symbol unified symbol of the market to fetch trades for
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.name] the name of the method to call, 'trade' or 'aggTrade', default is 'trade'
+     * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+     */
+    async unWatchTrades(symbol, params = {}) {
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        symbol = market['symbol'];
+        const messageHash = 'unsubscribe:trades:' + symbol;
+        let url = undefined;
+        if (market['spot']) {
+            url = this.urls['api']['ws']['spot'];
+            const channel = 'spot@public.deals.v3.api@' + market['id'];
+            params['unsubscribed'] = true;
+            this.watchSpotPublic(channel, messageHash, params);
+        }
+        else {
+            url = this.urls['api']['ws']['swap'];
+            const channel = 'unsub.deal';
+            const requestParams = {
+                'symbol': market['id'],
+            };
+            this.watchSwapPublic(channel, messageHash, requestParams, params);
+        }
+        const client = this.client(url);
+        this.handleUnsubscriptions(client, [messageHash]);
+        return undefined;
+    }
+    handleUnsubscriptions(client, messageHashes) {
+        for (let i = 0; i < messageHashes.length; i++) {
+            const messageHash = messageHashes[i];
+            const subMessageHash = messageHash.replace('unsubscribe:', '');
+            this.cleanUnsubscription(client, subMessageHash, messageHash);
+            if (messageHash.indexOf('ticker') >= 0) {
+                const symbol = messageHash.replace('unsubscribe:ticker:', '');
+                if (symbol.indexOf('unsubscribe') >= 0) {
+                    // unWatchTickers
+                    const symbols = Object.keys(this.tickers);
+                    for (let j = 0; j < symbols.length; j++) {
+                        delete this.tickers[symbols[j]];
+                    }
+                }
+                else if (symbol in this.tickers) {
+                    delete this.tickers[symbol];
+                }
+            }
+            else if (messageHash.indexOf('bidask') >= 0) {
+                const symbol = messageHash.replace('unsubscribe:bidask:', '');
+                if (symbol in this.bidsasks) {
+                    delete this.bidsasks[symbol];
+                }
+            }
+            else if (messageHash.indexOf('candles') >= 0) {
+                const splitHashes = messageHash.split(':');
+                let symbol = this.safeString(splitHashes, 2);
+                if (splitHashes.length > 4) {
+                    symbol += ':' + this.safeString(splitHashes, 3);
+                }
+                if (symbol in this.ohlcvs) {
+                    delete this.ohlcvs[symbol];
+                }
+            }
+            else if (messageHash.indexOf('orderbook') >= 0) {
+                const symbol = messageHash.replace('unsubscribe:orderbook:', '');
+                if (symbol in this.orderbooks) {
+                    delete this.orderbooks[symbol];
+                }
+            }
+            else if (messageHash.indexOf('trades') >= 0) {
+                const symbol = messageHash.replace('unsubscribe:trades:', '');
+                if (symbol in this.trades) {
+                    delete this.trades[symbol];
+                }
+            }
+        }
+    }
     async authenticate(subscriptionHash, params = {}) {
         // we only need one listenKey since ccxt shares connections
         let listenKey = this.safeString(this.options, 'listenKey');

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

@@ -249,7 +249,9 @@ class poloniex extends poloniex$1 {
                 request['price'] = this.priceToPrecision(symbol, price);
             }
         }
-        return await this.tradeRequest('createOrder', this.extend(request, params));
+        const orders = await this.tradeRequest('createOrder', this.extend(request, params));
+        const order = this.safeDict(orders, 0);
+        return order;
     }
     /**
      * @method
@@ -268,7 +270,9 @@ class poloniex extends poloniex$1 {
             const clientOrderIds = this.safeValue(params, 'clientOrderId', []);
             params['clientOrderIds'] = this.arrayConcat(clientOrderIds, [clientOrderId]);
         }
-        return await this.cancelOrdersWs([id], symbol, params);
+        const orders = await this.cancelOrdersWs([id], symbol, params);
+        const order = this.safeDict(orders, 0);
+        return order;
     }
     /**
      * @method

package/examples/js/cli.js

@@ -15,6 +15,21 @@ const { ExchangeError , NetworkError} = ccxt
 function jsonStringify (obj, indent = undefined) {
     return JSON.stringify (obj, function(k, v) { return v === undefined ? null : v; }, indent);
 }
+
+
+function countAllParams(fn) {
+    const fnStr = fn.toString()
+      .replace(/\/\/.*$/mg, '')
+      .replace(/\/\*[\s\S]*?\*\//mg, '')
+      .replace(/\s+/g, '');
+
+    const match = fnStr.match(/^[^(]*\(([^)]*)\)/);
+    if (!match) return 0;
+
+    const params = match[1].split(',').filter(p => p);
+    return params.length;
+}
+
 //-----------------------------------------------------------------------------
 
 let [processPath, , exchangeId, methodName, ... params] = process.argv.filter (x => !x.startsWith ('--'))
@@ -45,19 +60,63 @@ let [processPath, , exchangeId, methodName, ... params] = process.argv.filter (x
     , noKeys = process.argv.includes ('--no-keys')
 
 let foundDescription = undefined;
+const nameIndex = process.argv.indexOf ('--name')
+if (nameIndex >= 0) {
+    foundDescription = process.argv[nameIndex + 1];
+    // search that string in `params` and remove it
+    const index = params.indexOf (foundDescription)
+    if (index >= 0) {
+        params.splice (index, 1);
+    }
+}
+
+let lastParamObject
+let symbol
 for (let i = 0; i < process.argv.length; i++) {
-    if (process.argv[i] === '--name') {
-        foundDescription = process.argv[i + 1]; 
-        // search that string in `params` and remove it
-        for (let j = 0; j < params.length; j++) {
-            if (params[j] === foundDescription) {
-                params.splice(j, 1);
-                break;
+    if (process.argv[i] === '--param') {
+        const nextParam = process.argv[i + 1]
+        if (nextParam) {
+            const paramIndex = params.indexOf (nextParam)
+            if (paramIndex >= 0) {
+                if (nextParam.indexOf('=') >= 0) {
+                    const parsed = nextParam.split('=')
+                    if (parsed.length === 2) {
+                        if (!lastParamObject) {
+                            lastParamObject = {}
+                        }
+                        const key = parsed[0];
+                        const value = parsed[1];
+                        if (key === 'symbol') {
+                            symbol = value
+                        }
+                        lastParamObject[key] = value
+                        params.splice(paramIndex, 1)
+                    } else {
+                        throw new Error ('Invalid usage of --param. Please provide a key=value pair after --param.')
+                    }
+                } else {
+                    if (!lastParamObject) {
+                        lastParamObject = {}
+                    }
+                    lastParamObject[nextParam] = true
+                }
+            } else {
+                throw new Error (`Unexpected error by parsing parameters: ${nextParam} is not found in params array.`)
             }
+        } else {
+            throw new Error ('Invalid usage of --param. Please provide a value after --param.')
         }
-        break;
     }
 }
+
+let lastParam = params[params.length - 1]
+// exclude parasitic single quotes. Can happen on some shell processors
+if (lastParam?.includes('{') && lastParam?.includes('}')) {
+    if (lastParam.startsWith('\'{') && lastParam.endsWith('}\'')) {
+        lastParam = params[params.length - 1] = lastParam.substring(1, lastParam.length - 1)
+    }
+}
+
 //-----------------------------------------------------------------------------
 if (!raw) {
     log ((new Date ()).toISOString())
@@ -213,6 +272,7 @@ function printUsage () {
     log ('node', process.argv[1], 'okcoin fetchOHLCV BTC/USD 15m')
     log ('node', process.argv[1], 'bitfinex fetchBalance')
     log ('node', process.argv[1], 'kraken fetchOrderBook ETH/BTC')
+    log ('node', process.argv[1], 'binanceusdm fetchTrades BTC/USDC undefined undefined --param until=1746988377067')
     printSupportedExchanges ()
     log ('Supported options:')
     log ('--verbose         Print verbose output')
@@ -224,6 +284,8 @@ function printUsage () {
     log ('--no-table        Do not print the fetch response as a table')
     log ('--table           Print the fetch response as a table')
     log ('--iso8601         Print timestamps as ISO8601 datetimes')
+    log ('--param key=value Set a custom key=value pair for the last method\'s argument. Can be repeated multiple times')
+    log ('                  NOTE: don\'t forget to fill up missed arguments with "undefined" before last options parameter')
     log ('--cors            use CORS proxy for debugging')
     log ('--sign-in         Call signIn() if any')
     log ('--sandbox         Use the exchange sandbox if available, same as --testnet')
@@ -306,10 +368,16 @@ async function run () {
 
         let args = params
             .map (s => s.match (/^[0-9]{4}[-][0-9]{2}[-][0-9]{2}[T\s]?[0-9]{2}[:][0-9]{2}[:][0-9]{2}/g) ? exchange.parse8601 (s) : s)
-            .map (s => (() => { 
-                if (s.match ( /^\d+$/g)) return s < Number.MAX_SAFE_INTEGER ? Number (s) : s
-                try {return eval ('(() => (' + s + ')) ()') } catch (e) { return s }
-            }) ())
+            .map (s => {
+                return (() => {
+                    if (s.match(/^\d+$/g)) return s < Number.MAX_SAFE_INTEGER ? Number(s) : s
+                    try {
+                        return eval('(() => (' + s + ')) ()')
+                    } catch (e) {
+                        return s
+                    }
+                })();
+            })
 
         const www = Array.isArray (exchange.urls.www) ? exchange.urls.www[0] : exchange.urls.www
 
@@ -337,6 +405,34 @@ async function run () {
                 }
             }
         }
+        if (symbol && lastParamObject) {
+            let marketId
+            try {
+                marketId = exchange.marketId(symbol)
+            } catch (e) {
+                // noop possible loaded from cache
+            }
+            if (!marketId) {
+                try {
+                    await exchange.loadMarkets();
+                    marketId = exchange.marketId(symbol)
+                } catch (e) {
+                    // noop
+                }
+            }
+            if (marketId) {
+                lastParamObject.symbol = marketId
+            }
+        }
+
+        if (typeof lastParamObject === 'object') {
+            const lastArgument = args[args.length - 1];
+            if (lastParam && typeof lastArgument === 'object') {
+                args[args.length - 1]  = Object.assign (lastArgument, lastParamObject)
+            } else {
+                args.push (lastParamObject)
+            }
+        }
 
         if (signIn && exchange.has.signIn) {
             await exchange.signIn ()
@@ -363,7 +459,10 @@ async function run () {
 
             if (typeof exchange[methodName] === 'function') {
 
-                if (!raw) log (exchange.id + '.' + methodName, '(' + args.join (', ') + ')')
+                if (!raw || details) {
+                    const methodArgsPrint = JSON.stringify(args);
+                    log(exchange.id + '.' + methodName, '(' + methodArgsPrint.substring(1, methodArgsPrint.length - 1) + ')')
+                }
 
                 let start = exchange.milliseconds ()
                 let end = exchange.milliseconds ()
@@ -377,6 +476,21 @@ async function run () {
 
                 while (true) {
                     try {
+                        const fn = exchange[methodName]
+                        const fnParams = countAllParams(fn)
+                        const argsContainsParams = args.find( arg=> arg && typeof arg === 'object' && !Array.isArray(arg) && Object.keys(arg).length > 0)
+                        if (argsContainsParams && fnParams !== args.length) {
+                            // populate the missing params with undefined
+                            const missingParams = fnParams - args.length
+                            const paramsObj = args[args.length - 1]
+                            args.pop()
+                            const newArgsArray = args;
+                            for (let i = 0; i < missingParams; i++) {
+                                newArgsArray.push(undefined)
+                            }
+                            newArgsArray.push(paramsObj)
+                            args = newArgsArray
+                        }
                         const result = await exchange[methodName] (... args)
                         end = exchange.milliseconds ()
                         if (!isWsMethod && !raw) {