@grvt/client 1.4.1

package/ws/ws.js

@@ -0,0 +1,714 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WS = void 0;
+const interfaces_1 = require("../interfaces");
+const utils_1 = require("../utils");
+const interfaces_2 = require("./interfaces");
+class WS {
+    get _ws() {
+        if (!this.__ws) {
+            return this._createWs();
+        }
+        return this.__ws;
+    }
+    constructor(options) {
+        this._retries = 0;
+        this._connecting = true;
+        this._version = 'v1';
+        /**
+         * START: Pairs
+         */
+        this._pairs = {};
+        /**
+         * END: Pairs
+         */
+        this._onConnects = [];
+        this._onCloses = [];
+        this._onErrors = [];
+        this._options = options;
+    }
+    _createWs() {
+        if (this.__ws) {
+            this._close(this.__ws);
+        }
+        this._connecting = true;
+        this.__ws = new WebSocket(this._options.url, this._options.protocols);
+        this._bindWebSocketListeners(this.__ws);
+        return this.__ws;
+    }
+    _close(ws) {
+        const close = () => {
+            // force close
+            ws.close();
+            // if (ws.readyState !== WebSocket.CLOSED && ws.readyState !== WebSocket.CONNECTING) {
+            //   ws.close()
+            // }
+        };
+        ws.addEventListener('open', () => {
+            close();
+        });
+        ws.addEventListener('message', () => {
+            close();
+        });
+        ws.addEventListener('error', () => {
+            close();
+        });
+        close();
+    }
+    _bindWebSocketListeners(currentWs) {
+        for (const onConnect of this._onConnects) {
+            currentWs.addEventListener('open', onConnect);
+        }
+        for (const onClose of this._onCloses) {
+            currentWs.addEventListener('close', onClose);
+        }
+        for (const onError of this._onErrors) {
+            currentWs.addEventListener('error', onError);
+        }
+        const reconnect = () => {
+            var _a, _b, _c;
+            if (!this._connecting) {
+                return;
+            }
+            const retryTimeout = (_c = (_b = (_a = this._options).reconnectStrategy) === null || _b === void 0 ? void 0 : _b.call(_a, ++this._retries)) !== null && _c !== void 0 ? _c : new Error('No reconnect strategy');
+            if (typeof retryTimeout === 'number') {
+                return setTimeout(() => {
+                    if (currentWs !== this.__ws) {
+                        this._close(currentWs);
+                        return;
+                    }
+                    this._createWs();
+                }, retryTimeout);
+            }
+            throw retryTimeout;
+        };
+        currentWs.addEventListener('open', (e) => {
+            // only keep the latest ws
+            if (currentWs !== this.__ws) {
+                this._close(currentWs);
+                return;
+            }
+            this._subscribeCurrentPairs();
+        });
+        currentWs.addEventListener('close', () => {
+            // only keep the latest ws
+            if (currentWs !== this.__ws) {
+                this._close(currentWs);
+                return;
+            }
+            reconnect();
+        });
+        currentWs.addEventListener('error', () => {
+            // only keep the latest ws
+            if (currentWs !== this.__ws) {
+                this._close(currentWs);
+                return;
+            }
+            reconnect();
+        });
+        currentWs.addEventListener('message', (e) => {
+            var _a, _b, _c, _d, _e, _f;
+            // only keep the latest ws
+            if (currentWs !== this.__ws) {
+                this._close(currentWs);
+                return;
+            }
+            // reset retries
+            if (this._retries) {
+                this._retries = 0;
+            }
+            const message = utils_1.JsonUtils.parse(e.data);
+            /**
+             * Ignore 400 status response messages
+             */
+            if (message.status === 400) {
+                return;
+            }
+            const stream = message.s = (_b = (_a = message.s) === null || _a === void 0 ? void 0 : _a.replace) === null || _b === void 0 ? void 0 : _b.call(_a, `${this._version}.`, '');
+            const result = this._messageLiteToFull(message);
+            // no entity found
+            if (!result) {
+                // if no entity found and not a subscription message
+                if (!((_c = message.s1) === null || _c === void 0 ? void 0 : _c.length)) {
+                    console.warn('Error: something went wrong with message', message);
+                }
+                return;
+            }
+            if (!stream) {
+                console.warn('Error: cannot parse stream or feed from message', message);
+                return;
+            }
+            const instrument = (_f = (_e = (_d = result === null || result === void 0 ? void 0 : result.legs) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.instrument) !== null && _f !== void 0 ? _f : result === null || result === void 0 ? void 0 : result.instrument;
+            /**
+             * Handle subscriptions with instrument
+             */
+            const consumers = instrument
+                ? this._getInstrumentConsumers({ stream, instrument, result })
+                : this._getNonInstrumentConsumers({ stream, result });
+            if (!(consumers === null || consumers === void 0 ? void 0 : consumers.length)) {
+                // There are delay in sending unsubscribe message so clients might receive messages after unsubscribing
+                // console.log('TODO: send unsubscribe with by message:', message, result)
+                return;
+            }
+            if (result && (consumers === null || consumers === void 0 ? void 0 : consumers.length)) {
+                for (const consumer of consumers) {
+                    typeof consumer === 'function' && consumer(result);
+                }
+            }
+        });
+        /**
+         * Auto close after 10s of inactivity
+         */
+        let lastMessageAt = Date.now();
+        const autoCloseDelay = 10 * 1000;
+        const autoCloseInterval = setInterval(() => {
+            if (Date.now() - lastMessageAt > autoCloseDelay) {
+                reconnect();
+            }
+        }, autoCloseDelay);
+        /**
+         * Heartbeat every 3s
+         */
+        const heartbeatDelay = 3 * 1000;
+        const heartbeat = () => {
+            if (currentWs.readyState === WebSocket.OPEN && Date.now() - lastMessageAt > heartbeatDelay) {
+                currentWs.send('ping');
+            }
+        };
+        const heartbeatInterval = setInterval(heartbeat, heartbeatDelay);
+        currentWs.addEventListener('message', (e) => {
+            lastMessageAt = Date.now();
+        });
+        currentWs.addEventListener('close', () => {
+            clearInterval(autoCloseInterval);
+            clearInterval(heartbeatInterval);
+        });
+    }
+    /**
+     * Only use for TDG
+     * Use for TEntities of GROUP | STATE | DEPOSIT | TRANSFER | WITHDRAWAL streams
+     */
+    _getNonInstrumentConsumers({ result, stream }) {
+        return Object.entries(this._pairs).reduce((acc, [key, value]) => {
+            if (!key.startsWith(`${stream}__`)) {
+                return acc;
+            }
+            const depositDestinationAccountId = result.to_account_id;
+            const transferSourceKey = [
+                result.from_account_id,
+                result.from_sub_account_id ? result.from_sub_account_id : 0
+            ].filter(Boolean).join('-');
+            const transferDestinationKey = [
+                result.to_account_id,
+                result.to_sub_account_id ? result.to_sub_account_id : 0
+            ].filter(Boolean).join('-');
+            const withdrawalFromAccountId = result.from_account_id;
+            switch (stream) {
+                case interfaces_2.EStream.GROUP:
+                    return [...acc, ...Object.values(value)];
+                case interfaces_2.EStream.STATE:
+                    return [...acc, ...Object.values(value)];
+                case interfaces_2.EStream.DEPOSIT:
+                    if (depositDestinationAccountId && key.endsWith(depositDestinationAccountId)) {
+                        return [...acc, ...Object.values(value)];
+                    }
+                    break;
+                case interfaces_2.EStream.TRANSFER:
+                    if ((transferSourceKey && key.endsWith(transferSourceKey)) || (transferDestinationKey && key.endsWith(transferDestinationKey))) {
+                        return [...acc, ...Object.values(value)];
+                    }
+                    break;
+                case interfaces_2.EStream.WITHDRAWAL:
+                    if (withdrawalFromAccountId && key.endsWith(withdrawalFromAccountId)) {
+                        return [...acc, ...Object.values(value)];
+                    }
+                    break;
+            }
+            return acc;
+        }, []);
+    }
+    /**
+     * Use for MDG/TDG
+     * Use for TEntityHasInstrument
+     */
+    _getInstrumentConsumers({ result, stream, instrument }) {
+        return Object.entries(this._pairs).reduce((acc, [key, value]) => {
+            var _a, _b, _c;
+            if (!key.startsWith(`${stream}__`)) {
+                return acc;
+            }
+            const hasSubAccountId = [
+                interfaces_2.EStream.ORDER,
+                // EStream.STATE,
+                interfaces_2.EStream.POSITION,
+                interfaces_2.EStream.FILL
+                // EStream.DEPOSIT,
+                // EStream.TRANSFER,
+                // EStream.WITHDRAWAL
+            ].includes(stream);
+            // no sub account id handling
+            if (!hasSubAccountId) {
+                return key.includes(instrument)
+                    ? [...acc, ...Object.values(value)]
+                    : acc;
+            }
+            // has sub account id handling
+            const subAccountId = String(result.sub_account_id);
+            // const subAccountId = String((result as IPositions).sub_account_id)
+            // const subAccountId = String((result as IFill).sub_account_id)
+            const feed = (_a = this._parseStream({
+                stream: stream,
+                params: {
+                    sub_account_id: subAccountId,
+                    instrument
+                }
+            })) === null || _a === void 0 ? void 0 : _a.feed;
+            const tdgFeedPrefix = (_c = (_b = feed === null || feed === void 0 ? void 0 : feed[0]) === null || _b === void 0 ? void 0 : _b.split('@')) === null || _c === void 0 ? void 0 : _c[0];
+            if (tdgFeedPrefix && key.startsWith(`${stream}__${tdgFeedPrefix}`)) {
+                return [...acc, ...Object.values(value)];
+            }
+            return acc;
+        }, []);
+    }
+    _parseStream(options) {
+        const candleFeed = (params) => [
+            params.instrument,
+            [
+                params.interval,
+                params.type
+            ].filter(Boolean).join('-')
+        ].filter(Boolean).join('@');
+        const bookDeltaFeed = (params) => {
+            var _a;
+            return [
+                params.instrument,
+                [
+                    (_a = params.rate) !== null && _a !== void 0 ? _a : 1000
+                ].filter(Boolean).join('-')
+            ].filter(Boolean).join('@');
+        };
+        const bookFeed = (params) => {
+            var _a, _b;
+            return [
+                params.instrument,
+                [
+                    (_a = params.rate) !== null && _a !== void 0 ? _a : 1000,
+                    (_b = params.depth) !== null && _b !== void 0 ? _b : 10
+                ].filter(Boolean).join('-')
+            ].filter(Boolean).join('@');
+        };
+        const miniFeed = (params) => {
+            var _a;
+            return [
+                params.instrument,
+                [
+                    (_a = params.rate) !== null && _a !== void 0 ? _a : 1000
+                ].filter(Boolean).join('-')
+            ].filter(Boolean).join('@');
+        };
+        const tickerFeed = (params) => {
+            var _a;
+            return [
+                params.instrument,
+                [
+                    (_a = params.rate) !== null && _a !== void 0 ? _a : 1000
+                ].filter(Boolean).join('-')
+            ].filter(Boolean).join('@');
+        };
+        const publicTradesFeed = (params) => {
+            var _a;
+            return [
+                params.instrument,
+                [
+                    (_a = params.limit) !== null && _a !== void 0 ? _a : 500
+                ].filter(Boolean).join('-')
+            ].filter(Boolean).join('@');
+        };
+        /**
+         * TDG
+         */
+        const orderGroupFeed = (params) => [
+            [
+                params.sub_account_id
+            ].filter(Boolean).join('-')
+            // [
+            //   {
+            //     all: 'a',
+            //     createOnly: 'c',
+            //     updateOnly: 'u'
+            //   }[params.state_filter] || 'a'
+            // ].filter(Boolean).join('-')
+        ].filter(Boolean).join('@');
+        const orderFeed = (params) => [
+            [
+                params.sub_account_id,
+                params.instrument
+            ].filter(Boolean).join('-')
+            // [
+            //   {
+            //     all: 'a',
+            //     createOnly: 'c',
+            //     updateOnly: 'u'
+            //   }[params.state_filter] || 'a'
+            // ].filter(Boolean).join('-')
+        ].filter(Boolean).join('@');
+        const orderStateFeed = (params) => [
+            [
+                params.sub_account_id,
+                params.instrument
+            ].filter(Boolean).join('-')
+            // [
+            //   {
+            //     all: 'a',
+            //     createOnly: 'c',
+            //     updateOnly: 'u'
+            //   }[params.state_filter] || 'a'
+            // ].filter(Boolean).join('-')
+        ].filter(Boolean).join('@');
+        const positionFeed = (params) => [
+            [
+                params.sub_account_id,
+                params.instrument
+            ].filter(Boolean).join('-')
+            // [
+            //   params.createOnly
+            // ].filter(Boolean).join('-')
+        ].filter(Boolean).join('@');
+        const fillFeed = (params) => [
+            [
+                params.sub_account_id,
+                params.instrument
+            ].filter(Boolean).join('-')
+            // [
+            //   params.createOnly
+            // ].filter(Boolean).join('-')
+        ].filter(Boolean).join('@');
+        const depositFeed = (params) => {
+            return params.main_account_id;
+        };
+        const transferFeed = (params) => {
+            if (params.sub_account_id) {
+                return [params.main_account_id, params.sub_account_id].join('-');
+            }
+            return params.main_account_id;
+        };
+        const withdrawalFeed = (params) => {
+            return params.main_account_id;
+        };
+        const { stream, params } = options;
+        switch (stream) {
+            case interfaces_2.EStream.CANDLE:
+                return {
+                    stream,
+                    feed: [candleFeed(params)]
+                };
+            case interfaces_2.EStream.ORDERBOOK_DELTA:
+                return {
+                    stream,
+                    feed: [bookDeltaFeed(params)]
+                };
+            case interfaces_2.EStream.ORDERBOOK_SNAP:
+                return {
+                    stream,
+                    feed: [bookFeed(params)]
+                };
+            case interfaces_2.EStream.MINI_DELTA:
+            case interfaces_2.EStream.MINI_SNAP:
+                return {
+                    stream,
+                    feed: [miniFeed(params)]
+                };
+            case interfaces_2.EStream.TICKER_DELTA:
+            case interfaces_2.EStream.TICKER_SNAP:
+                return {
+                    stream,
+                    feed: [tickerFeed(params)]
+                };
+            case interfaces_2.EStream.TRADE:
+                return {
+                    stream,
+                    feed: [publicTradesFeed(params)]
+                };
+            case interfaces_2.EStream.GROUP:
+                return {
+                    stream,
+                    feed: [orderGroupFeed(params)]
+                };
+            case interfaces_2.EStream.ORDER:
+                return {
+                    stream,
+                    feed: [orderFeed(params)]
+                };
+            case interfaces_2.EStream.STATE:
+                return {
+                    stream,
+                    feed: [orderStateFeed(params)]
+                };
+            case interfaces_2.EStream.POSITION:
+                return {
+                    stream,
+                    feed: [positionFeed(params)]
+                };
+            case interfaces_2.EStream.FILL:
+                return {
+                    stream,
+                    feed: [fillFeed(params)]
+                };
+            case interfaces_2.EStream.DEPOSIT:
+                return {
+                    stream,
+                    feed: [depositFeed(params)]
+                };
+            case interfaces_2.EStream.TRANSFER:
+                return {
+                    stream,
+                    feed: [transferFeed(params)]
+                };
+            case interfaces_2.EStream.WITHDRAWAL:
+                return {
+                    stream,
+                    feed: [withdrawalFeed(params)]
+                };
+            default:
+                console.warn('Unknown stream: ' + stream);
+        }
+    }
+    _messageLiteToFull(message) {
+        switch (message.s) {
+            case interfaces_2.EStream.CANDLE:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_CANDLESTICK_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.ORDERBOOK_DELTA:
+            case interfaces_2.EStream.ORDERBOOK_SNAP:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_ORDERBOOK_LEVELS_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.MINI_DELTA:
+            case interfaces_2.EStream.MINI_SNAP:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_MINI_TICKER_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.TICKER_DELTA:
+            case interfaces_2.EStream.TICKER_SNAP:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_TICKER_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.TRADE:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_TRADE_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.GROUP:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_ORDER_GROUP_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.ORDER:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_ORDER_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.STATE:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_ORDER_STATE_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.POSITION:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_POSITIONS_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.FILL:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_FILL_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.DEPOSIT:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_DEPOSIT_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.TRANSFER:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_TRANSFER_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            case interfaces_2.EStream.WITHDRAWAL:
+                return utils_1.Utils.schemaMap(message, interfaces_1.WS_WITHDRAWAL_FEED_DATA_V_1_MAP.LITE_TO_FULL).feed;
+            default:
+                console.warn('Unknown message:', message);
+        }
+    }
+    _sendMessage(payload) {
+        if (this._ws.readyState === WebSocket.OPEN) {
+            this._ws.send(JSON.stringify(Object.assign(Object.assign({}, payload), { stream: `${this._version}.${payload.stream}` })));
+        }
+    }
+    _getPair({ stream, feed }) {
+        return `${stream}__${feed}`;
+    }
+    _parsePair(pair) {
+        var _a;
+        const [stream, feed] = pair.split('__');
+        return {
+            stream,
+            feed,
+            asset: (_a = feed === null || feed === void 0 ? void 0 : feed.split('@')) === null || _a === void 0 ? void 0 : _a[0]
+        };
+    }
+    _addConsumer(pair, onMessage) {
+        var _a;
+        if (!this._pairs[pair]) {
+            this._pairs[pair] = {};
+        }
+        const key = (_a = Object.entries(this._pairs[pair]).find(([, consumer]) => consumer === onMessage)) === null || _a === void 0 ? void 0 : _a[0];
+        if (key) {
+            return `${pair}__${key}`; // already bound
+        }
+        const consumerKey = `${Date.now()}${utils_1.StringUtils.randChars(3)}`;
+        this._pairs[pair][consumerKey] = onMessage;
+        return `${pair}__${consumerKey}`;
+    }
+    _removeConsumer(pairedConsumerKey) {
+        const [stream, feed, consumerKey] = pairedConsumerKey.split('__');
+        const pairKey = this._getPair({ stream, feed });
+        if (!this._pairs[pairKey]) {
+            return;
+        }
+        let needUnsubscribe = true;
+        const pairPrimary = pairKey.split('@')[0];
+        for (const key of Object.keys(this._pairs)) {
+            if (key.split('@')[0] !== pairPrimary) {
+                continue;
+            }
+            const primaryGroup = this._pairs[key];
+            const _a = primaryGroup, _b = consumerKey, _ = _a[_b], keep = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+            this._pairs[key] = keep;
+            if (Object.keys(keep).length) {
+                needUnsubscribe = false;
+            }
+        }
+        if (needUnsubscribe) {
+            this._sendMessage({
+                method: 'unsubscribe',
+                stream,
+                feed: [feed]
+            });
+        }
+    }
+    setParams(params) {
+        const url = new URL(this._options.url.toString());
+        for (const [key, value] of Object.entries(params)) {
+            url.searchParams.set(key, value);
+        }
+        this._options.url = url;
+        this._createWs();
+        return this;
+    }
+    onConnect(callback) {
+        this._onConnects.push(callback);
+        this._ws.addEventListener('open', callback);
+        return () => {
+            this._ws.removeEventListener('open', callback);
+            this._onConnects.splice(this._onConnects.indexOf(callback), 1);
+        };
+    }
+    onClose(callback) {
+        this._onCloses.push(callback);
+        this._ws.addEventListener('close', callback);
+        return () => {
+            this._ws.removeEventListener('close', callback);
+            this._onCloses.splice(this._onCloses.indexOf(callback), 1);
+        };
+    }
+    onError(callback) {
+        this._onErrors.push(callback);
+        this._ws.addEventListener('error', callback);
+        return () => {
+            this._ws.removeEventListener('error', callback);
+            this._onErrors.splice(this._onErrors.indexOf(callback), 1);
+        };
+    }
+    _subscribeCurrentPairs() {
+        const pairs = Object.keys(this._pairs);
+        for (const pair of pairs) {
+            const { stream, feed } = this._parsePair(pair);
+            this._sendMessage({
+                method: 'subscribe',
+                stream,
+                feed: [feed]
+            });
+        }
+    }
+    _subscribe(pair, subscribePayload) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Object.keys(this._pairs[pair] || {}).length) {
+                return;
+            }
+            yield this.ready();
+            let _resolve;
+            const onPaired = (e) => {
+                var _a, _b, _c;
+                const message = utils_1.JsonUtils.parse(e.data);
+                if (!(message === null || message === void 0 ? void 0 : message.s) || !((_a = message === null || message === void 0 ? void 0 : message.s1) === null || _a === void 0 ? void 0 : _a.length)) {
+                    return;
+                }
+                const responseStream = (_c = (_b = message.s) === null || _b === void 0 ? void 0 : _b.replace) === null || _c === void 0 ? void 0 : _c.call(_b, `${this._version}.`, '');
+                const { stream, feed } = this._parsePair(pair);
+                const asset = feed.split('@')[0];
+                const subs = message.s1;
+                const isResolved = stream === responseStream && (subs.includes(asset) ||
+                    subs.includes(asset.toLowerCase()) ||
+                    subs.includes(feed) ||
+                    subs.includes(feed.toLowerCase()));
+                if (isResolved) {
+                    _resolve();
+                }
+            };
+            const promise = new Promise((resolve) => {
+                _resolve = resolve;
+                this._ws.addEventListener('message', onPaired);
+            });
+            this._sendMessage(subscribePayload);
+            return utils_1.Utils.timeout(promise, (_a = this._options.timeout) !== null && _a !== void 0 ? _a : 30000, new Error('Subscribe Timeout: ' + pair)).finally(() => {
+                this._ws.removeEventListener('message', onPaired);
+            });
+        });
+    }
+    /**
+     * Only supports one feed
+     */
+    subscribe(_options) {
+        var _a;
+        const { onData: onMessage, onError } = _options, options = __rest(_options, ["onData", "onError"]);
+        const subscribePayload = Object.assign(Object.assign({}, this._parseStream(options)), { method: 'subscribe' });
+        const stream = subscribePayload.stream;
+        const feed = (_a = subscribePayload.feed) === null || _a === void 0 ? void 0 : _a[0];
+        if (!stream || !feed) {
+            throw new Error('Unknown stream or feed');
+        }
+        const pair = this._getPair({ stream, feed });
+        void this._subscribe(pair, subscribePayload).catch(onError);
+        return this._addConsumer(pair, onMessage);
+    }
+    unsubscribe(pairedConsumerKey) {
+        this._removeConsumer(pairedConsumerKey);
+        return this;
+    }
+    connect() {
+        this._createWs();
+        return this;
+    }
+    disconnect() {
+        if (this.__ws) {
+            this._close(this.__ws);
+            this.__ws = undefined;
+        }
+        this._connecting = false;
+        return this;
+    }
+    ready(delay = 100) {
+        if (this._ws.readyState === WebSocket.OPEN) {
+            return Promise.resolve(this);
+        }
+        if (this._ws.readyState === WebSocket.CLOSED) {
+            return Promise.reject(new Error('WebSocket is closed'));
+        }
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve(this.ready());
+            }, delay);
+        });
+    }
+}
+exports.WS = WS;