ccxt 4.2.94 → 4.2.96

package/dist/cjs/src/coinex.js

@@ -1088,8 +1088,8 @@ class coinex extends coinex$1 {
          * @method
          * @name coinex#fetchOrderBook
          * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
-         * @see https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot001_market004_market_depth
-         * @see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http010_market_depth
+         * @see https://docs.coinex.com/api/v2/spot/market/http/list-market-depth
+         * @see https://docs.coinex.com/api/v2/futures/market/http/list-market-depth
          * @param {string} symbol unified symbol of the market to fetch the order book for
          * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
@@ -1101,65 +1101,71 @@ class coinex extends coinex$1 {
             limit = 20; // default
         }
         const request = {
-            'market': this.marketId(symbol),
-            'merge': '0',
-            'limit': limit.toString(),
+            'market': market['id'],
+            'limit': limit,
+            'interval': '0',
         };
         let response = undefined;
         if (market['swap']) {
-            response = await this.v1PerpetualPublicGetMarketDepth(this.extend(request, params));
+            response = await this.v2PublicGetFuturesDepth(this.extend(request, params));
+            //
+            //     {
+            //         "code": 0,
+            //         "data": {
+            //             "depth": {
+            //                 "asks": [
+            //                     ["70851.94", "0.2119"],
+            //                     ["70851.95", "0.0004"],
+            //                     ["70851.96", "0.0004"]
+            //                 ],
+            //                 "bids": [
+            //                     ["70851.93", "1.0314"],
+            //                     ["70850.93", "0.0021"],
+            //                     ["70850.42", "0.0306"]
+            //                 ],
+            //                 "checksum": 2956436260,
+            //                 "last": "70851.94",
+            //                 "updated_at": 1712824003252
+            //             },
+            //             "is_full": true,
+            //             "market": "BTCUSDT"
+            //         },
+            //         "message": "OK"
+            //     }
+            //
         }
         else {
-            response = await this.v1PublicGetMarketDepth(this.extend(request, params));
+            response = await this.v2PublicGetSpotDepth(this.extend(request, params));
+            //
+            //     {
+            //         "code": 0,
+            //         "data": {
+            //             "depth": {
+            //                 "asks": [
+            //                     ["70875.31", "0.28670282"],
+            //                     ["70875.32", "0.31008114"],
+            //                     ["70875.42", "0.05876653"]
+            //                 ],
+            //                 "bids": [
+            //                     ["70855.3", "0.00632222"],
+            //                     ["70855.29", "0.36216834"],
+            //                     ["70855.17", "0.10166802"]
+            //                 ],
+            //                 "checksum": 2313816665,
+            //                 "last": "70857.19",
+            //                 "updated_at": 1712823790987
+            //             },
+            //             "is_full": true,
+            //             "market": "BTCUSDT"
+            //         },
+            //         "message": "OK"
+            //     }
+            //
         }
-        //
-        // Spot
-        //
-        //     {
-        //         "code": 0,
-        //         "data": {
-        //             "asks": [
-        //                 ["41056.33", "0.31727613"],
-        //                 ["41056.34", "1.05657294"],
-        //                 ["41056.35", "0.02346648"]
-        //             ],
-        //             "bids": [
-        //                 ["41050.61", "0.40618608"],
-        //                 ["41046.98", "0.13800000"],
-        //                 ["41046.56", "0.22579234"]
-        //             ],
-        //             "last": "41050.61",
-        //             "time": 1650573220346
-        //         },
-        //         "message": "OK"
-        //     }
-        //
-        // Swap
-        //
-        //     {
-        //         "code": 0,
-        //         "data": {
-        //             "asks": [
-        //                 ["40620.90", "0.0384"],
-        //                 ["40625.50", "0.0219"],
-        //                 ["40625.90", "0.3506"]
-        //             ],
-        //             "bids": [
-        //                 ["40620.89", "19.6861"],
-        //                 ["40620.80", "0.0012"],
-        //                 ["40619.87", "0.0365"]
-        //             ],
-        //             "last": "40620.89",
-        //             "time": 1650587672406,
-        //             "sign_price": "40619.32",
-        //             "index_price": "40609.93"
-        //         },
-        //         "message": "OK"
-        //     }
-        //
-        const result = this.safeValue(response, 'data', {});
-        const timestamp = this.safeInteger(result, 'time');
-        return this.parseOrderBook(result, symbol, timestamp);
+        const data = this.safeDict(response, 'data', {});
+        const depth = this.safeDict(data, 'depth', {});
+        const timestamp = this.safeInteger(depth, 'updated_at');
+        return this.parseOrderBook(depth, symbol, timestamp);
     }
     parseTrade(trade, market = undefined) {
         //

package/dist/cjs/src/gemini.js

@@ -285,7 +285,13 @@ class gemini extends gemini$1 {
                     'ATOM': 'cosmos',
                     'DOT': 'polkadot',
                 },
-                'nonce': 'milliseconds', // if getting a Network 400 error change to seconds
+                'nonce': 'milliseconds',
+                'conflictingMarkets': {
+                    'paxgusd': {
+                        'base': 'PAXG',
+                        'quote': 'USD',
+                    },
+                },
             },
         });
     }
@@ -679,16 +685,29 @@ class gemini extends gemini$1 {
             const marketIdUpper = marketId.toUpperCase();
             const isPerp = (marketIdUpper.indexOf('PERP') >= 0);
             const marketIdWithoutPerp = marketIdUpper.replace('PERP', '');
-            const quoteQurrencies = this.handleOption('fetchMarketsFromAPI', 'quoteCurrencies', []);
-            for (let i = 0; i < quoteQurrencies.length; i++) {
-                const quoteCurrency = quoteQurrencies[i];
-                if (marketIdWithoutPerp.endsWith(quoteCurrency)) {
-                    baseId = marketIdWithoutPerp.replace(quoteCurrency, '');
-                    quoteId = quoteCurrency;
-                    if (isPerp) {
-                        settleId = quoteCurrency; // always same
+            const conflictingMarkets = this.safeDict(this.options, 'conflictingMarkets', {});
+            const lowerCaseId = marketIdWithoutPerp.toLowerCase();
+            if (lowerCaseId in conflictingMarkets) {
+                const conflictingMarket = conflictingMarkets[lowerCaseId];
+                baseId = conflictingMarket['base'];
+                quoteId = conflictingMarket['quote'];
+                if (isPerp) {
+                    settleId = conflictingMarket['quote'];
+                }
+            }
+            else {
+                const quoteCurrencies = this.handleOption('fetchMarketsFromAPI', 'quoteCurrencies', []);
+                for (let i = 0; i < quoteCurrencies.length; i++) {
+                    const quoteCurrency = quoteCurrencies[i];
+                    if (marketIdWithoutPerp.endsWith(quoteCurrency)) {
+                        const quoteLength = this.parseToInt(-1 * quoteCurrency.length);
+                        baseId = marketIdWithoutPerp.slice(0, quoteLength);
+                        quoteId = quoteCurrency;
+                        if (isPerp) {
+                            settleId = quoteCurrency; // always same
+                        }
+                        break;
                     }
-                    break;
                 }
             }
         }

package/dist/cjs/src/htx.js

@@ -940,14 +940,8 @@ class htx extends htx$1 {
                 'fetchMarkets': {
                     'types': {
                         'spot': true,
-                        'future': {
-                            'linear': true,
-                            'inverse': true,
-                        },
-                        'swap': {
-                            'linear': true,
-                            'inverse': true,
-                        },
+                        'linear': true,
+                        'inverse': true,
                     },
                 },
                 'fetchOHLCV': {
@@ -1614,25 +1608,23 @@ class htx extends htx$1 {
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object[]} an array of objects representing market data
          */
-        const options = this.safeValue(this.options, 'fetchMarkets', {});
-        const types = this.safeValue(options, 'types', {});
+        let types = undefined;
+        [types, params] = this.handleOptionAndParams(params, 'fetchMarkets', 'types', {});
         let allMarkets = [];
         let promises = [];
         const keys = Object.keys(types);
         for (let i = 0; i < keys.length; i++) {
-            const type = keys[i];
-            const value = this.safeValue(types, type);
-            if (value === true) {
-                promises.push(this.fetchMarketsByTypeAndSubType(type, undefined, params));
-            }
-            else if (value) {
-                const subKeys = Object.keys(value);
-                for (let j = 0; j < subKeys.length; j++) {
-                    const subType = subKeys[j];
-                    const subValue = this.safeValue(value, subType);
-                    if (subValue) {
-                        promises.push(this.fetchMarketsByTypeAndSubType(type, subType, params));
-                    }
+            const key = keys[i];
+            if (this.safeBool(types, key)) {
+                if (key === 'spot') {
+                    promises.push(this.fetchMarketsByTypeAndSubType('spot', undefined, params));
+                }
+                else if (key === 'linear') {
+                    promises.push(this.fetchMarketsByTypeAndSubType(undefined, 'linear', params));
+                }
+                else if (key === 'inverse') {
+                    promises.push(this.fetchMarketsByTypeAndSubType('swap', 'inverse', params));
+                    promises.push(this.fetchMarketsByTypeAndSubType('future', 'inverse', params));
                 }
             }
         }
@@ -1643,35 +1635,25 @@ class htx extends htx$1 {
         return allMarkets;
     }
     async fetchMarketsByTypeAndSubType(type, subType, params = {}) {
-        const query = this.omit(params, ['type', 'subType']);
-        const spot = (type === 'spot');
-        const contract = (type !== 'spot');
-        const future = (type === 'future');
-        const swap = (type === 'swap');
-        let linear = undefined;
-        let inverse = undefined;
+        const isSpot = (type === 'spot');
         const request = {};
         let response = undefined;
-        if (contract) {
-            linear = (subType === 'linear');
-            inverse = (subType === 'inverse');
-            if (linear) {
-                if (future) {
-                    request['business_type'] = 'futures';
-                }
-                response = await this.contractPublicGetLinearSwapApiV1SwapContractInfo(this.extend(request, query));
+        if (!isSpot) {
+            if (subType === 'linear') {
+                request['business_type'] = 'all'; // override default to fetch all linear markets
+                response = await this.contractPublicGetLinearSwapApiV1SwapContractInfo(this.extend(request, params));
             }
-            else if (inverse) {
-                if (future) {
-                    response = await this.contractPublicGetApiV1ContractContractInfo(this.extend(request, query));
+            else if (subType === 'inverse') {
+                if (type === 'future') {
+                    response = await this.contractPublicGetApiV1ContractContractInfo(this.extend(request, params));
                 }
-                else if (swap) {
-                    response = await this.contractPublicGetSwapApiV1SwapContractInfo(this.extend(request, query));
+                else if (type === 'swap') {
+                    response = await this.contractPublicGetSwapApiV1SwapContractInfo(this.extend(request, params));
                 }
             }
         }
         else {
-            response = await this.spotPublicGetV1CommonSymbols(this.extend(request, query));
+            response = await this.spotPublicGetV1CommonSymbols(this.extend(request, params));
         }
         //
         // spot
@@ -1711,75 +1693,58 @@ class htx extends htx$1 {
         //         ]
         //     }
         //
-        // inverse future
+        // inverse (swap & future)
         //
         //     {
         //         "status":"ok",
         //         "data":[
         //             {
         //                 "symbol":"BTC",
-        //                 "contract_code":"BTC211126",
-        //                 "contract_type":"this_week",
-        //                 "contract_size":100.000000000000000000,
-        //                 "price_tick":0.010000000000000000,
-        //                 "delivery_date":"20211126",
-        //                 "delivery_time":"1637913600000",
+        //                 "contract_code":"BTC211126", /// BTC-USD in swap
+        //                 "contract_type":"this_week", // only in future
+        //                 "contract_size":100,
+        //                 "price_tick":0.1,
+        //                 "delivery_date":"20211126", // only in future
+        //                 "delivery_time":"1637913600000", // empty in swap
         //                 "create_date":"20211112",
         //                 "contract_status":1,
-        //                 "settlement_time":"1637481600000"
+        //                 "settlement_time":"1637481600000" // only in future
+        //                 "settlement_date":"16xxxxxxxxxxx" // only in swap
         //             },
+        //           ...
         //         ],
         //         "ts":1637474595140
         //     }
         //
-        // linear futures
+        // linear (swap & future)
         //
         //     {
         //         "status":"ok",
         //         "data":[
         //             {
         //                 "symbol":"BTC",
-        //                 "contract_code":"BTC-USDT-211231",
-        //                 "contract_size":0.001000000000000000,
-        //                 "price_tick":0.100000000000000000,
-        //                 "delivery_date":"20211231",
-        //                 "delivery_time":"1640937600000",
+        //                 "contract_code":"BTC-USDT-211231", // or "BTC-USDT" in swap
+        //                 "contract_size":0.001,
+        //                 "price_tick":0.1,
+        //                 "delivery_date":"20211231", // empty in swap
+        //                 "delivery_time":"1640937600000", // empty in swap
         //                 "create_date":"20211228",
         //                 "contract_status":1,
         //                 "settlement_date":"1640764800000",
-        //                 "support_margin_mode":"cross",
-        //                 "business_type":"futures",
+        //                 "support_margin_mode":"cross", // "all" or "cross"
+        //                 "business_type":"futures", // "swap" or "futures"
         //                 "pair":"BTC-USDT",
-        //                 "contract_type":"this_week" // next_week, quarter
-        //             },
+        //                 "contract_type":"this_week", // "swap", "this_week", "next_week", "quarter"
+        //                 "trade_partition":"USDT",
+        //             }
         //         ],
         //         "ts":1640736207263
         //     }
         //
-        // swaps
-        //
-        //     {
-        //         "status":"ok",
-        //         "data":[
-        //             {
-        //                 "symbol":"BTC",
-        //                 "contract_code":"BTC-USDT",
-        //                 "contract_size":0.001000000000000000,
-        //                 "price_tick":0.100000000000000000,
-        //                 "delivery_time":"",
-        //                 "create_date":"20201021",
-        //                 "contract_status":1,
-        //                 "settlement_date":"1637481600000",
-        //                 "support_margin_mode":"all", // isolated
-        //             },
-        //         ],
-        //         "ts":1637474774467
-        //     }
-        //
-        const markets = this.safeValue(response, 'data', []);
+        const markets = this.safeList(response, 'data', []);
         const numMarkets = markets.length;
         if (numMarkets < 1) {
-            throw new errors.NetworkError(this.id + ' fetchMarkets() returned an empty response: ' + this.json(markets));
+            throw new errors.OperationFailed(this.id + ' fetchMarkets() returned an empty response: ' + this.json(response));
         }
         const result = [];
         for (let i = 0; i < markets.length; i++) {
@@ -1789,16 +1754,31 @@ class htx extends htx$1 {
             let settleId = undefined;
             let id = undefined;
             let lowercaseId = undefined;
+            const contract = ('contract_code' in market);
+            const spot = !contract;
+            let swap = false;
+            let future = false;
+            let linear = undefined;
+            let inverse = undefined;
+            // check if parsed market is contract
             if (contract) {
                 id = this.safeString(market, 'contract_code');
                 lowercaseId = id.toLowerCase();
+                const delivery_date = this.safeString(market, 'delivery_date');
+                const business_type = this.safeString(market, 'business_type');
+                future = delivery_date !== undefined;
+                swap = !future;
+                linear = business_type !== undefined;
+                inverse = !linear;
                 if (swap) {
+                    type = 'swap';
                     const parts = id.split('-');
                     baseId = this.safeStringLower(market, 'symbol');
                     quoteId = this.safeStringLower(parts, 1);
                     settleId = inverse ? baseId : quoteId;
                 }
                 else if (future) {
+                    type = 'future';
                     baseId = this.safeStringLower(market, 'symbol');
                     if (inverse) {
                         quoteId = 'USD';
@@ -1813,6 +1793,7 @@ class htx extends htx$1 {
                 }
             }
             else {
+                type = 'spot';
                 baseId = this.safeString(market, 'base-currency');
                 quoteId = this.safeString(market, 'quote-currency');
                 id = baseId + quoteId;
@@ -1947,6 +1928,45 @@ class htx extends htx$1 {
         }
         return result;
     }
+    tryGetSymbolFromFutureMarkets(symbolOrMarketId) {
+        if (symbolOrMarketId in this.markets) {
+            return symbolOrMarketId;
+        }
+        // only on "future" market type (inverse & linear), market-id differs between "fetchMarkets" and "fetchTicker"
+        // so we have to create a mapping
+        // - market-id from fetchMarkts:    `BTC-USDT-240419` (linear future) or `BTC240412` (inverse future)
+        // - market-id from fetchTciker[s]: `BTC-USDT-CW`     (linear future) or `BTC_CW`    (inverse future)
+        if (!('futureMarketIdsForSymbols' in this.options)) {
+            this.options['futureMarketIdsForSymbols'] = {};
+        }
+        const futureMarketIdsForSymbols = this.safeDict(this.options, 'futureMarketIdsForSymbols', {});
+        if (symbolOrMarketId in futureMarketIdsForSymbols) {
+            return futureMarketIdsForSymbols[symbolOrMarketId];
+        }
+        const futureMarkets = this.filterBy(this.markets, 'future', true);
+        const futuresCharsMaps = {
+            'this_week': 'CW',
+            'next_week': 'NW',
+            'quarter': 'CQ',
+            'next_quarter': 'NQ',
+        };
+        for (let i = 0; i < futureMarkets.length; i++) {
+            const market = futureMarkets[i];
+            const info = this.safeValue(market, 'info', {});
+            const contractType = this.safeString(info, 'contract_type');
+            const contractSuffix = futuresCharsMaps[contractType];
+            // see comment on formats a bit above
+            const constructedId = market['linear'] ? market['base'] + '-' + market['quote'] + '-' + contractSuffix : market['base'] + '_' + contractSuffix;
+            if (constructedId === symbolOrMarketId) {
+                const symbol = market['symbol'];
+                this.options['futureMarketIdsForSymbols'][symbolOrMarketId] = symbol;
+                return symbol;
+            }
+        }
+        // if not found, just save it to avoid unnecessary future iterations
+        this.options['futureMarketIdsForSymbols'][symbolOrMarketId] = symbolOrMarketId;
+        return symbolOrMarketId;
+    }
     parseTicker(ticker, market = undefined) {
         //
         // fetchTicker
@@ -1994,7 +2014,8 @@ class htx extends htx$1 {
         //     }
         //
         const marketId = this.safeString2(ticker, 'symbol', 'contract_code');
-        const symbol = this.safeSymbol(marketId, market);
+        let symbol = this.safeSymbol(marketId, market);
+        symbol = this.tryGetSymbolFromFutureMarkets(symbol);
         const timestamp = this.safeInteger2(ticker, 'ts', 'quoteTime');
         let bid = undefined;
         let bidVolume = undefined;
@@ -2137,7 +2158,7 @@ class htx extends htx$1 {
          * @see https://huobiapi.github.io/docs/usdt_swap/v1/en/#general-get-a-batch-of-market-data-overview
          * @see https://huobiapi.github.io/docs/dm/v1/en/#get-a-batch-of-market-data-overview
          * @see https://huobiapi.github.io/docs/coin_margined_swap/v1/en/#get-a-batch-of-market-data-overview-v2
-         * @param {string[]|undefined} symbols unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
+         * @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
          * @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
@@ -2148,22 +2169,30 @@ class htx extends htx$1 {
         if (first !== undefined) {
             market = this.market(first);
         }
+        const isSubTypeRequested = ('subType' in params) || ('business_type' in params);
         let type = undefined;
         let subType = undefined;
         [type, params] = this.handleMarketTypeAndParams('fetchTickers', market, params);
         [subType, params] = this.handleSubTypeAndParams('fetchTickers', market, params);
         const request = {};
+        const isSpot = (type === 'spot');
         const future = (type === 'future');
         const swap = (type === 'swap');
         const linear = (subType === 'linear');
         const inverse = (subType === 'inverse');
-        params = this.omit(params, ['type', 'subType']);
         let response = undefined;
-        if (future || swap) {
+        if (!isSpot || isSubTypeRequested) {
             if (linear) {
+                // independently of type, supports calling all linear symbols i.e. fetchTickers(undefined, {subType:'linear'})
                 if (future) {
                     request['business_type'] = 'futures';
                 }
+                else if (swap) {
+                    request['business_type'] = 'swap';
+                }
+                else {
+                    request['business_type'] = 'all';
+                }
                 response = await this.contractPublicGetLinearSwapExMarketDetailBatchMerged(this.extend(request, params));
             }
             else if (inverse) {
@@ -2173,6 +2202,12 @@ class htx extends htx$1 {
                 else if (swap) {
                     response = await this.contractPublicGetSwapExMarketDetailBatchMerged(this.extend(request, params));
                 }
+                else {
+                    throw new errors.NotSupported(this.id + ' fetchTickers() you have to set params["type"] to either "swap" or "future" for inverse contracts');
+                }
+            }
+            else {
+                throw new errors.NotSupported(this.id + ' fetchTickers() you have to set params["subType"] to either "linear" or "inverse" for contracts');
             }
         }
         else {
@@ -2228,42 +2263,9 @@ class htx extends htx$1 {
         //         "ts":1637504679376
         //     }
         //
-        const tickers = this.safeValue2(response, 'data', 'ticks', []);
-        const timestamp = this.safeInteger(response, 'ts');
-        const result = {};
-        for (let i = 0; i < tickers.length; i++) {
-            const ticker = this.parseTicker(tickers[i]);
-            // the market ids for linear futures are non-standard and differ from all the other endpoints
-            // we are doing a linear-matching here
-            if (future && linear) {
-                for (let j = 0; j < this.symbols.length; j++) {
-                    const symbolInner = this.symbols[j];
-                    const marketInner = this.market(symbolInner);
-                    const contractType = this.safeString(marketInner['info'], 'contract_type');
-                    if ((contractType === 'this_week') && (ticker['symbol'] === (marketInner['baseId'] + '-' + marketInner['quoteId'] + '-CW'))) {
-                        ticker['symbol'] = marketInner['symbol'];
-                        break;
-                    }
-                    else if ((contractType === 'next_week') && (ticker['symbol'] === (marketInner['baseId'] + '-' + marketInner['quoteId'] + '-NW'))) {
-                        ticker['symbol'] = marketInner['symbol'];
-                        break;
-                    }
-                    else if ((contractType === 'this_quarter') && (ticker['symbol'] === (marketInner['baseId'] + '-' + marketInner['quoteId'] + '-CQ'))) {
-                        ticker['symbol'] = marketInner['symbol'];
-                        break;
-                    }
-                    else if ((contractType === 'next_quarter') && (ticker['symbol'] === (marketInner['baseId'] + '-' + marketInner['quoteId'] + '-NQ'))) {
-                        ticker['symbol'] = marketInner['symbol'];
-                        break;
-                    }
-                }
-            }
-            const symbol = ticker['symbol'];
-            ticker['timestamp'] = timestamp;
-            ticker['datetime'] = this.iso8601(timestamp);
-            result[symbol] = ticker;
-        }
-        return this.filterByArrayTickers(result, 'symbol', symbols);
+        const rawTickers = this.safeList2(response, 'data', 'ticks', []);
+        const tickers = this.parseTickers(rawTickers, symbols, params);
+        return this.filterByArrayTickers(tickers, 'symbol', symbols);
     }
     async fetchLastPrices(symbols = undefined, params = {}) {
         /**
@@ -2273,7 +2275,7 @@ class htx extends htx$1 {
          * @see https://www.htx.com/en-us/opend/newApiPages/?id=8cb81024-77b5-11ed-9966-0242ac110003 linear swap & linear future
          * @see https://www.htx.com/en-us/opend/newApiPages/?id=28c2e8fc-77ae-11ed-9966-0242ac110003 inverse future
          * @see https://www.htx.com/en-us/opend/newApiPages/?id=5d517ef5-77b6-11ed-9966-0242ac110003 inverse swap
-         * @param {string[]|undefined} symbols unified symbols of the markets to fetch the last prices
+         * @param {string[]} [symbols] unified symbols of the markets to fetch the last prices
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a dictionary of lastprices structures
          */