ccxt 4.5.18 → 4.5.20

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var xt$1 = require('../xt.js');
 var Cache = require('../base/ws/Cache.js');
+var errors = require('../base/errors.js');
 
 // ----------------------------------------------------------------------------
 //  ---------------------------------------------------------------------------
@@ -13,10 +14,15 @@ class xt extends xt$1["default"] {
             'has': {
                 'ws': true,
                 'watchOHLCV': true,
+                'unWatchOHLCV': true,
                 'watchOrderBook': true,
+                'unWatchOrderBook': true,
                 'watchTicker': true,
+                'unWatchTicker': true,
                 'watchTickers': true,
+                'unWatchTickers': true,
                 'watchTrades': true,
+                'unWatchTrades': true,
                 'watchTradesForSymbols': false,
                 'watchBalance': true,
                 'watchOrders': true,
@@ -161,9 +167,10 @@ class xt extends xt$1["default"] {
         let type = undefined;
         [type, params] = this.handleMarketTypeAndParams(methodName, market, params);
         const isContract = (type !== 'spot');
+        const id = this.numberToString(this.milliseconds()) + name; // call back ID
         const subscribe = {
             'method': isContract ? 'SUBSCRIBE' : 'subscribe',
-            'id': this.numberToString(this.milliseconds()) + name, // call back ID
+            'id': id,
         };
         if (privateAccess) {
             if (!isContract) {
@@ -189,8 +196,73 @@ class xt extends xt$1["default"] {
         if (isContract) {
             tail = privateAccess ? 'user' : 'market';
         }
+        const subscription = {
+            'id': id,
+        };
+        const url = this.urls['api']['ws'][tradeType] + '/' + tail;
+        return await this.watch(url, messageHash, request, messageHash, subscription);
+    }
+    /**
+     * @ignore
+     * @method
+     * @description Connects to a websocket channel
+     * @see https://doc.xt.com/#websocket_privaterequestFormat
+     * @see https://doc.xt.com/#futures_market_websocket_v2base
+     * @param {string} messageHash the message hash of the subscription
+     * @param {string} name name of the channel
+     * @param {string} access public or private
+     * @param {string} methodName the name of the CCXT class method
+     * @param {string} topic topic of the subscription
+     * @param {object} [market] CCXT market
+     * @param {string[]} [symbols] unified market symbols
+     * @param {object} params extra parameters specific to the xt api
+     * @param {object} subscriptionParams extra parameters specific to the subscription
+     * @returns {object} data from the websocket stream
+     */
+    async unSubscribe(messageHash, name, access, methodName, topic, market = undefined, symbols = undefined, params = {}, subscriptionParams = {}) {
+        const privateAccess = access === 'private';
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams(methodName, market, params);
+        const isContract = (type !== 'spot');
+        const id = this.numberToString(this.milliseconds()) + name; // call back ID
+        const unsubscribe = {
+            'method': isContract ? 'UNSUBSCRIBE' : 'unsubscribe',
+            'id': id,
+        };
+        if (privateAccess) {
+            if (!isContract) {
+                unsubscribe['params'] = [name];
+                unsubscribe['listenKey'] = await this.getListenKey(isContract);
+            }
+            else {
+                const listenKey = await this.getListenKey(isContract);
+                const param = name + '@' + listenKey;
+                unsubscribe['params'] = [param];
+            }
+        }
+        else {
+            unsubscribe['params'] = [name];
+        }
+        const tradeType = isContract ? 'contract' : 'spot';
+        let subMessageHash = name + '::' + tradeType;
+        if (symbols !== undefined) {
+            subMessageHash = subMessageHash + '::' + symbols.join(',');
+        }
+        const request = this.extend(unsubscribe, params);
+        let tail = access;
+        if (isContract) {
+            tail = privateAccess ? 'user' : 'market';
+        }
         const url = this.urls['api']['ws'][tradeType] + '/' + tail;
-        return await this.watch(url, messageHash, request, messageHash);
+        const subscription = {
+            'unsubscribe': true,
+            'id': id,
+            'subMessageHashes': [subMessageHash],
+            'messageHashes': [messageHash],
+            'symbols': symbols,
+            'topic': topic,
+        };
+        return await this.watch(url, messageHash, this.extend(request, params), messageHash, this.extend(subscription, subscriptionParams));
     }
     /**
      * @method
@@ -215,7 +287,29 @@ class xt extends xt$1["default"] {
     }
     /**
      * @method
-     * @name xt#watchTicker
+     * @name xt#unWatchTicker
+     * @description stops watching a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+     * @see https://doc.xt.com/#websocket_publictickerRealTime
+     * @see https://doc.xt.com/#futures_market_websocket_v2tickerRealTime
+     * @see https://doc.xt.com/#futures_market_websocket_v2aggTickerRealTime
+     * @param {string} symbol unified symbol of the market to fetch the ticker for
+     * @param {object} params extra parameters specific to the xt api endpoint
+     * @param {string} [params.method] 'agg_ticker' (contract only) or 'ticker', default = 'ticker' - the endpoint that will be streamed
+     * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/en/latest/manual.html#ticker-structure}
+     */
+    async unWatchTicker(symbol, params = {}) {
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const options = this.safeDict(this.options, 'unWatchTicker');
+        const defaultMethod = this.safeString(options, 'method', 'ticker');
+        const method = this.safeString(params, 'method', defaultMethod);
+        const name = method + '@' + market['id'];
+        const messageHash = 'unsubscribe::' + name;
+        return await this.unSubscribe(messageHash, name, 'public', 'unWatchTicker', defaultMethod, market, undefined, params);
+    }
+    /**
+     * @method
+     * @name xt#watchTickers
      * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
      * @see https://doc.xt.com/#websocket_publicallTicker
      * @see https://doc.xt.com/#futures_market_websocket_v2allTicker
@@ -230,6 +324,7 @@ class xt extends xt$1["default"] {
         const options = this.safeDict(this.options, 'watchTickers');
         const defaultMethod = this.safeString(options, 'method', 'tickers');
         const name = this.safeString(params, 'method', defaultMethod);
+        symbols = this.marketSymbols(symbols);
         let market = undefined;
         if (symbols !== undefined) {
             market = this.market(symbols[0]);
@@ -242,7 +337,34 @@ class xt extends xt$1["default"] {
     }
     /**
      * @method
-     * @name hitbtc#watchOHLCV
+     * @name xt#unWatchTickers
+     * @description stops watching a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+     * @see https://doc.xt.com/#websocket_publicallTicker
+     * @see https://doc.xt.com/#futures_market_websocket_v2allTicker
+     * @see https://doc.xt.com/#futures_market_websocket_v2allAggTicker
+     * @param {string} [symbols] unified market symbols
+     * @param {object} params extra parameters specific to the xt api endpoint
+     * @param {string} [params.method] 'agg_tickers' (contract only) or 'tickers', default = 'tickers' - the endpoint that will be streamed
+     * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/en/latest/manual.html#ticker-structure}
+     */
+    async unWatchTickers(symbols = undefined, params = {}) {
+        await this.loadMarkets();
+        const options = this.safeDict(this.options, 'unWatchTickers');
+        const defaultMethod = this.safeString(options, 'method', 'tickers');
+        const name = this.safeString(params, 'method', defaultMethod);
+        if (symbols !== undefined) {
+            throw new errors.NotSupported(this.id + ' unWatchTickers() does not support symbols argument, unsubscribtion is for all tickers at once only');
+        }
+        const messageHash = 'unsubscribe::' + name;
+        const tickers = await this.unSubscribe(messageHash, name, 'public', 'unWatchTickers', 'ticker', undefined, symbols, params);
+        if (this.newUpdates) {
+            return tickers;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
+    /**
+     * @method
+     * @name xt#watchOHLCV
      * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
      * @see https://doc.xt.com/#websocket_publicsymbolKline
      * @see https://doc.xt.com/#futures_market_websocket_v2symbolKline
@@ -263,6 +385,25 @@ class xt extends xt$1["default"] {
         }
         return this.filterBySinceLimit(ohlcv, since, limit, 0, true);
     }
+    /**
+     * @method
+     * @name xt#unWatchOHLCV
+     * @description stops watching historical candlestick data containing the open, high, low, and close price, and the volume of a market
+     * @see https://doc.xt.com/#websocket_publicsymbolKline
+     * @see https://doc.xt.com/#futures_market_websocket_v2symbolKline
+     * @param {string} symbol unified symbol of the market to fetch OHLCV data for
+     * @param {string} timeframe 1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h, 8h, 12h, 1d, 3d, 1w, or 1M
+     * @param {object} params extra parameters specific to the xt api endpoint
+     * @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);
+        const name = 'kline@' + market['id'] + ',' + timeframe;
+        const messageHash = 'unsubscribe::' + name;
+        params['symbolsAndTimeframes'] = [[market['symbol'], timeframe]];
+        return await this.unSubscribe(messageHash, name, 'public', 'unWatchOHLCV', 'kline', market, undefined, params);
+    }
     /**
      * @method
      * @name xt#watchTrades
@@ -285,6 +426,23 @@ class xt extends xt$1["default"] {
         }
         return this.filterBySinceLimit(trades, since, limit, 'timestamp');
     }
+    /**
+     * @method
+     * @name xt#unWatchTrades
+     * @description stops watching the list of most recent trades for a particular symbol
+     * @see https://doc.xt.com/#websocket_publicdealRecord
+     * @see https://doc.xt.com/#futures_market_websocket_v2dealRecord
+     * @param {string} symbol unified symbol of the market to fetch trades for
+     * @param {object} params extra parameters specific to the xt api endpoint
+     * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/en/latest/manual.html?#public-trades}
+     */
+    async unWatchTrades(symbol, params = {}) {
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const name = 'trade@' + market['id'];
+        const messageHash = 'unsubscribe::' + name;
+        return await this.unSubscribe(messageHash, name, 'public', 'unWatchTrades', 'trade', market, undefined, params);
+    }
     /**
      * @method
      * @name xt#watchOrderBook
@@ -311,6 +469,31 @@ class xt extends xt$1["default"] {
         const orderbook = await this.subscribe(name, 'public', 'watchOrderBook', market, undefined, params);
         return orderbook.limit();
     }
+    /**
+     * @method
+     * @name xt#unWatchOrderBook
+     * @description stops watching information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+     * @see https://doc.xt.com/#websocket_publiclimitDepth
+     * @see https://doc.xt.com/#websocket_publicincreDepth
+     * @see https://doc.xt.com/#futures_market_websocket_v2limitDepth
+     * @see https://doc.xt.com/#futures_market_websocket_v2increDepth
+     * @param {string} symbol unified symbol of the market to fetch the order book for
+     * @param {object} params extra parameters specific to the xt api endpoint
+     * @param {int} [params.levels] 5, 10, 20, or 50
+     * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/en/latest/manual.html#order-book-structure} indexed by market symbols
+     */
+    async unWatchOrderBook(symbol, params = {}) {
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const levels = this.safeString(params, 'levels');
+        params = this.omit(params, 'levels');
+        let name = 'depth_update@' + market['id'];
+        if (levels !== undefined) {
+            name = 'depth@' + market['id'] + ',' + levels;
+        }
+        const messageHash = 'unsubscribe::' + name;
+        return await this.unSubscribe(messageHash, name, 'public', 'unWatchOrderBook', 'depth', market, undefined, params);
+    }
     /**
      * @method
      * @name xt#watchOrders
@@ -1205,11 +1388,42 @@ class xt extends xt$1["default"] {
                 method.call(this, client, message);
             }
         }
+        else {
+            this.handleSubscriptionStatus(client, message);
+        }
     }
     ping(client) {
         client.lastPong = this.milliseconds();
         return 'ping';
     }
+    handleSubscriptionStatus(client, message) {
+        //
+        //     {
+        //         id: '1763045665228ticker@eth_usdt',
+        //         code: 0,
+        //         msg: 'SUCCESS',
+        //         method: 'unsubscribe'
+        //     }
+        //
+        const method = this.safeStringLower(message, 'method');
+        if (method === 'unsubscribe') {
+            const id = this.safeString(message, 'id');
+            const subscriptionsById = this.indexBy(client.subscriptions, 'id');
+            const subscription = this.safeValue(subscriptionsById, id, {});
+            this.handleUnSubscription(client, subscription);
+        }
+        return message;
+    }
+    handleUnSubscription(client, subscription) {
+        const messageHashes = this.safeList(subscription, 'messageHashes', []);
+        const subMessageHashes = this.safeList(subscription, 'subMessageHashes', []);
+        for (let j = 0; j < messageHashes.length; j++) {
+            const unsubHash = messageHashes[j];
+            const subHash = subMessageHashes[j];
+            this.cleanUnsubscription(client, subHash, unsubHash);
+        }
+        this.cleanCache(subscription);
+    }
     handleErrorMessage(client, message) {
         //
         //    {

package/dist/cjs/src/protobuf/mexc/compiled.cjs.js

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+require('../../../_virtual/_commonjsHelpers.js');
 var require$$0 = require('protobufjs/minimal');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

package/dist/cjs/src/static_dependencies/dydx-v4-client/cosmos/base/v1beta1/coin.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _m0 = require('protobufjs/minimal.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _m0__default = /*#__PURE__*/_interopDefaultLegacy(_m0);
+
+// ----------------------------------------------------------------------------
+function createBaseCoin() {
+    return {
+        denom: "",
+        amount: ""
+    };
+}
+const Coin = {
+    encode(message, writer = _m0__default["default"].Writer.create()) {
+        if (message.denom !== "") {
+            writer.uint32(10).string(message.denom);
+        }
+        if (message.amount !== "") {
+            writer.uint32(18).string(message.amount);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0__default["default"].Reader ? input : new _m0__default["default"].Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCoin();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.denom = reader.string();
+                    break;
+                case 2:
+                    message.amount = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCoin();
+        message.denom = object.denom ?? "";
+        message.amount = object.amount ?? "";
+        return message;
+    }
+};
+
+exports.Coin = Coin;

package/dist/cjs/src/static_dependencies/dydx-v4-client/cosmos/crypto/multisig/v1beta1/multisig.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _m0 = require('protobufjs/minimal.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _m0__default = /*#__PURE__*/_interopDefaultLegacy(_m0);
+
+// ----------------------------------------------------------------------------
+function createBaseCompactBitArray() {
+    return {
+        extraBitsStored: 0,
+        elems: new Uint8Array()
+    };
+}
+const CompactBitArray = {
+    encode(message, writer = _m0__default["default"].Writer.create()) {
+        if (message.extraBitsStored !== 0) {
+            writer.uint32(8).uint32(message.extraBitsStored);
+        }
+        if (message.elems.length !== 0) {
+            writer.uint32(18).bytes(message.elems);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0__default["default"].Reader ? input : new _m0__default["default"].Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCompactBitArray();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.extraBitsStored = reader.uint32();
+                    break;
+                case 2:
+                    message.elems = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCompactBitArray();
+        message.extraBitsStored = object.extraBitsStored ?? 0;
+        message.elems = object.elems ?? new Uint8Array();
+        return message;
+    }
+};
+
+exports.CompactBitArray = CompactBitArray;

package/dist/cjs/src/static_dependencies/dydx-v4-client/cosmos/crypto/secp256k1/keys.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _m0 = require('protobufjs/minimal.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _m0__default = /*#__PURE__*/_interopDefaultLegacy(_m0);
+
+// ----------------------------------------------------------------------------
+function createBasePubKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+const PubKey = {
+    encode(message, writer = _m0__default["default"].Writer.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0__default["default"].Reader ? input : new _m0__default["default"].Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePubKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePubKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    }
+};
+
+exports.PubKey = PubKey;