@tastytrade/api 1.0.0 → 2.1.0

package/.env

@@ -1,5 +1,4 @@
 BASE_URL=https://api.cert.tastyworks.com
 API_USERNAME=devin.moss@tastytrade.com
 API_PASSWORD=rebuke-padding-vizor
-API_ACCOUNT_NUMBER=5WT05179
-API_CUSTOMER_ID=31
+API_ACCOUNT_NUMBER=5WT05179

package/README.md

@@ -18,30 +18,36 @@ const accountPositions = await tastytradeClient.balancesAndPositionsService.getP
 
 ### Market Data
 ```js
-import TastytradeClient, { QuoteStreamer } from "@tastytrade-api"
+import TastytradeClient, { MarketDataStreamer, MarketDataSubscriptionType } from "@tastytrade-api"
 const tastytradeClient = new TastytradeClient(baseUrl, accountStreamerUrl)
 await tastytradeClient.sessionService.login(usernameOrEmail, pasword)
-const tokenResponse = await tastytradeClient.AccountsAndCustomersService.getQuoteStreamerTokens()
-const quoteStreamer = new QuoteStreamer(tokenResponse.token, `${tokenResponse['websocket-url']}/cometd`)
-quoteStreamer.connect()
+const tokenResponse = await tastytradeClient.AccountsAndCustomersService.getApiQuoteToken()
+const streamer = new MarketDataStreamer()
+streamer.connect(tokenResponse['dxlink-url'], tokenResponse.token)
 
-function handleMarketDataReceived(event) {
+function handleMarketDataReceived(data) {
   // Triggers every time market data event occurs
-  console.log(event)
+  console.log(data)
 }
+
+// Add a listener for incoming market data. Returns a remove() function that removes the listener from the quote streamer
+const removeDataListener = streamer.addDataListener(handleMarketDataReceived)
+
 // Subscribe to a single equity quote
-quoteStreamer.subscribe('AAPL', handleMarketDataReceived)
+streamer.addSubscription('AAPL')
+// Optionally specify which market data events you want to subscribe to
+streamer.addSubscription('SPY', { subscriptionTypes: [MarketDataSubscriptionType.Quote] })
 
 // Subscribe to a single equity option quote
 const optionChain = await tastytradeClient.instrumentsService.getOptionChain('AAPL')
-quoteStreamer.subscribe(optionChain[0]['streamer-symbol'], handleMarketDataReceived)
+streamer.addSubscription(optionChain[0]['streamer-symbol'])
 ```
 
 ### Account Streamer
 ```js
 const TastytradeApi = require("@tastytrade/api")
 const TastytradeClient = TastytradeApi.default
-const { AccountStreamer, QuoteStreamer } = TastytradeApi
+const { AccountStreamer } = TastytradeApi
 const _ = require('lodash')
 
 function handleStreamerMessage(json) {
@@ -79,6 +85,16 @@ global.window = { WebSocket, setTimeout, clearTimeout }
 `npm run build`
 Outputs everything to `dist/`
 
+## Running tests locally
+Add a `.env` file with the following keys (you'll have to fill in the values yourself):
+
+```
+BASE_URL=https://api.cert.tastyworks.com
+API_USERNAME=<your cert username>
+API_PASSWORD=<your cert password>
+API_ACCOUNT_NUMBER=<your cert account number>
+```
+
 ## Running example app
 ```sh
 npm run build

package/dist/market-data-streamer.d.ts

@@ -0,0 +1,95 @@
+export declare enum MarketDataSubscriptionType {
+    Candle = "Candle",
+    Quote = "Quote",
+    Trade = "Trade",
+    Summary = "Summary",
+    Profile = "Profile",
+    Greeks = "Greeks",
+    Underlying = "Underlying"
+}
+export declare enum CandleType {
+    Tick = "t",
+    Second = "s",
+    Minute = "m",
+    Hour = "h",
+    Day = "d",
+    Week = "w",
+    Month = "mo",
+    ThirdFriday = "o",
+    Year = "y",
+    Volume = "v",
+    Price = "p"
+}
+export declare type MarketDataListener = (data: any) => void;
+export declare type ErrorListener = (error: any) => void;
+export declare type AuthStateListener = (isAuthorized: boolean) => void;
+export declare type CandleSubscriptionOptions = {
+    period: number;
+    type: CandleType;
+    channelId: number;
+};
+declare type Remover = () => void;
+export default class MarketDataStreamer {
+    private webSocket;
+    private token;
+    private keepaliveIntervalId;
+    private dataListeners;
+    private openChannels;
+    private subscriptionsQueue;
+    private authState;
+    private errorListeners;
+    private authStateListeners;
+    addDataListener(dataListener: MarketDataListener, channelId?: number | null): Remover;
+    addErrorListener(errorListener: ErrorListener): Remover;
+    addAuthStateChangeListener(authStateListener: AuthStateListener): Remover;
+    connect(url: string, token: string): void;
+    disconnect(): void;
+    addSubscription(symbol: string, options?: {
+        subscriptionTypes: MarketDataSubscriptionType[];
+        channelId: number;
+    }): Remover;
+    /**
+     * Adds a candle subscription (historical data)
+     * @param streamerSymbol Get this from an instrument's streamer-symbol json response field
+     * @param fromTime Epoch timestamp from where you want to start
+     * @param options Period and Type are the grouping you want to apply to the candle data
+     * For example, a period/type of 5/m means you want each candle to represent 5 minutes of data
+     * From there, setting fromTime to 24 hours ago would give you 24 hours of data grouped in 5 minute intervals
+     * @returns
+     */
+    addCandleSubscription(streamerSymbol: string, fromTime: number, options: CandleSubscriptionOptions): () => void;
+    removeSubscription(symbol: string, options?: {
+        subscriptionTypes: MarketDataSubscriptionType[];
+        channelId: number;
+    }): void;
+    removeAllSubscriptions(channelId?: number): void;
+    openFeedChannel(channelId: number): void;
+    isChannelOpened(channelId: number): boolean;
+    get isReadyToOpenChannels(): boolean;
+    get isConnected(): boolean;
+    private scheduleKeepalive;
+    private sendKeepalive;
+    private queueSubscription;
+    private dequeueSubscription;
+    private sendQueuedSubscriptions;
+    /**
+     *
+     * @param {*} symbol
+     * @param {*} subscriptionTypes
+     * @param {*} channelId
+     * @param {*} direction add or remove
+     */
+    private sendSubscriptionMessage;
+    private onError;
+    private onOpen;
+    private onClose;
+    private clearKeepalive;
+    get isDxLinkAuthorized(): boolean;
+    private handleAuthStateMessage;
+    private handleChannelOpened;
+    private notifyListeners;
+    private notifyErrorListeners;
+    private handleMessageReceived;
+    private sendMessage;
+}
+export {};

package/dist/market-data-streamer.js

@@ -0,0 +1,345 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CandleType = exports.MarketDataSubscriptionType = void 0;
+var isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+var lodash_1 = __importDefault(require("lodash"));
+var uuid_1 = require("uuid");
+var MarketDataSubscriptionType;
+(function (MarketDataSubscriptionType) {
+    MarketDataSubscriptionType["Candle"] = "Candle";
+    MarketDataSubscriptionType["Quote"] = "Quote";
+    MarketDataSubscriptionType["Trade"] = "Trade";
+    MarketDataSubscriptionType["Summary"] = "Summary";
+    MarketDataSubscriptionType["Profile"] = "Profile";
+    MarketDataSubscriptionType["Greeks"] = "Greeks";
+    MarketDataSubscriptionType["Underlying"] = "Underlying";
+})(MarketDataSubscriptionType = exports.MarketDataSubscriptionType || (exports.MarketDataSubscriptionType = {}));
+var CandleType;
+(function (CandleType) {
+    CandleType["Tick"] = "t";
+    CandleType["Second"] = "s";
+    CandleType["Minute"] = "m";
+    CandleType["Hour"] = "h";
+    CandleType["Day"] = "d";
+    CandleType["Week"] = "w";
+    CandleType["Month"] = "mo";
+    CandleType["ThirdFriday"] = "o";
+    CandleType["Year"] = "y";
+    CandleType["Volume"] = "v";
+    CandleType["Price"] = "p";
+})(CandleType = exports.CandleType || (exports.CandleType = {}));
+// List of all subscription types except for Candle
+var AllSubscriptionTypes = Object.values(MarketDataSubscriptionType);
+var KeepaliveInterval = 30000; // 30 seconds
+var DefaultChannelId = 1;
+var MarketDataStreamer = /** @class */ (function () {
+    function MarketDataStreamer() {
+        this.webSocket = null;
+        this.token = '';
+        this.keepaliveIntervalId = null;
+        this.dataListeners = new Map();
+        this.openChannels = new Set();
+        this.subscriptionsQueue = new Map();
+        this.authState = '';
+        this.errorListeners = new Map();
+        this.authStateListeners = new Map();
+    }
+    MarketDataStreamer.prototype.addDataListener = function (dataListener, channelId) {
+        var _this = this;
+        if (channelId === void 0) { channelId = null; }
+        if (lodash_1.default.isNil(dataListener)) {
+            return lodash_1.default.noop;
+        }
+        var guid = (0, uuid_1.v4)();
+        this.dataListeners.set(guid, { listener: dataListener, channelId: channelId });
+        return function () { return _this.dataListeners.delete(guid); };
+    };
+    MarketDataStreamer.prototype.addErrorListener = function (errorListener) {
+        var _this = this;
+        if (lodash_1.default.isNil(errorListener)) {
+            return lodash_1.default.noop;
+        }
+        var guid = (0, uuid_1.v4)();
+        this.errorListeners.set(guid, errorListener);
+        return function () { return _this.errorListeners.delete(guid); };
+    };
+    MarketDataStreamer.prototype.addAuthStateChangeListener = function (authStateListener) {
+        var _this = this;
+        if (lodash_1.default.isNil(authStateListener)) {
+            return lodash_1.default.noop;
+        }
+        var guid = (0, uuid_1.v4)();
+        this.authStateListeners.set(guid, authStateListener);
+        return function () { return _this.authStateListeners.delete(guid); };
+    };
+    MarketDataStreamer.prototype.connect = function (url, token) {
+        if (this.isConnected) {
+            throw new Error('MarketDataStreamer is attempting to connect when an existing websocket is already connected');
+        }
+        this.token = token;
+        this.webSocket = new isomorphic_ws_1.default(url);
+        this.webSocket.onopen = this.onOpen.bind(this);
+        this.webSocket.onerror = this.onError.bind(this);
+        this.webSocket.onmessage = this.handleMessageReceived.bind(this);
+        this.webSocket.onclose = this.onClose.bind(this);
+    };
+    MarketDataStreamer.prototype.disconnect = function () {
+        if (lodash_1.default.isNil(this.webSocket)) {
+            return;
+        }
+        this.clearKeepalive();
+        this.webSocket.onopen = null;
+        this.webSocket.onerror = null;
+        this.webSocket.onmessage = null;
+        this.webSocket.onclose = null;
+        this.webSocket.close();
+        this.webSocket = null;
+        this.openChannels.clear();
+        this.subscriptionsQueue.clear();
+        this.authState = '';
+    };
+    MarketDataStreamer.prototype.addSubscription = function (symbol, options) {
+        var _this = this;
+        if (options === void 0) { options = { subscriptionTypes: AllSubscriptionTypes, channelId: DefaultChannelId }; }
+        var subscriptionTypes = options.subscriptionTypes;
+        // Don't allow candle subscriptions in this method. Use addCandleSubscription instead
+        subscriptionTypes = lodash_1.default.without(subscriptionTypes, MarketDataSubscriptionType.Candle);
+        var isOpen = this.isChannelOpened(options.channelId);
+        if (isOpen) {
+            this.sendSubscriptionMessage(symbol, subscriptionTypes, options.channelId, 'add');
+        }
+        else {
+            this.queueSubscription(symbol, { subscriptionTypes: subscriptionTypes, channelId: options.channelId });
+        }
+        return function () {
+            _this.removeSubscription(symbol, options);
+        };
+    };
+    /**
+     * Adds a candle subscription (historical data)
+     * @param streamerSymbol Get this from an instrument's streamer-symbol json response field
+     * @param fromTime Epoch timestamp from where you want to start
+     * @param options Period and Type are the grouping you want to apply to the candle data
+     * For example, a period/type of 5/m means you want each candle to represent 5 minutes of data
+     * From there, setting fromTime to 24 hours ago would give you 24 hours of data grouped in 5 minute intervals
+     * @returns
+     */
+    MarketDataStreamer.prototype.addCandleSubscription = function (streamerSymbol, fromTime, options) {
+        var _this = this;
+        var _a;
+        var subscriptionTypes = [MarketDataSubscriptionType.Candle];
+        var channelId = (_a = options.channelId) !== null && _a !== void 0 ? _a : DefaultChannelId;
+        // Example: AAPL{=5m} where each candle represents 5 minutes of data
+        var candleSymbol = "".concat(streamerSymbol, "{=").concat(options.period).concat(options.type, "}");
+        var isOpen = this.isChannelOpened(channelId);
+        var subscriptionArgs = { fromTime: fromTime };
+        if (isOpen) {
+            this.sendSubscriptionMessage(candleSymbol, subscriptionTypes, channelId, 'add', subscriptionArgs);
+        }
+        else {
+            this.queueSubscription(candleSymbol, { subscriptionTypes: subscriptionTypes, channelId: channelId, subscriptionArgs: subscriptionArgs });
+        }
+        return function () {
+            _this.removeSubscription(candleSymbol, { subscriptionTypes: subscriptionTypes, channelId: channelId });
+        };
+    };
+    MarketDataStreamer.prototype.removeSubscription = function (symbol, options) {
+        if (options === void 0) { options = { subscriptionTypes: AllSubscriptionTypes, channelId: DefaultChannelId }; }
+        var subscriptionTypes = options.subscriptionTypes, channelId = options.channelId;
+        var isOpen = this.isChannelOpened(channelId);
+        if (isOpen) {
+            this.sendSubscriptionMessage(symbol, subscriptionTypes, channelId, 'remove');
+        }
+        else {
+            this.dequeueSubscription(symbol, options);
+        }
+    };
+    MarketDataStreamer.prototype.removeAllSubscriptions = function (channelId) {
+        if (channelId === void 0) { channelId = DefaultChannelId; }
+        var isOpen = this.isChannelOpened(channelId);
+        if (isOpen) {
+            this.sendMessage({ "type": "FEED_SUBSCRIPTION", "channel": channelId, reset: true });
+        }
+        else {
+            this.subscriptionsQueue.set(channelId, []);
+        }
+    };
+    MarketDataStreamer.prototype.openFeedChannel = function (channelId) {
+        if (!this.isReadyToOpenChannels) {
+            throw new Error("Unable to open channel ".concat(channelId, " due to DxLink authorization state: ").concat(this.authState));
+        }
+        if (this.isChannelOpened(channelId)) {
+            return;
+        }
+        this.sendMessage({
+            "type": "CHANNEL_REQUEST",
+            "channel": channelId,
+            "service": "FEED",
+            "parameters": {
+                "contract": "AUTO"
+            }
+        });
+    };
+    MarketDataStreamer.prototype.isChannelOpened = function (channelId) {
+        return this.isConnected && this.openChannels.has(channelId);
+    };
+    Object.defineProperty(MarketDataStreamer.prototype, "isReadyToOpenChannels", {
+        get: function () {
+            return this.isConnected && this.isDxLinkAuthorized;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MarketDataStreamer.prototype, "isConnected", {
+        get: function () {
+            return !lodash_1.default.isNil(this.webSocket);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MarketDataStreamer.prototype.scheduleKeepalive = function () {
+        this.keepaliveIntervalId = setInterval(this.sendKeepalive, KeepaliveInterval);
+    };
+    MarketDataStreamer.prototype.sendKeepalive = function () {
+        if (lodash_1.default.isNil(this.keepaliveIntervalId)) {
+            return;
+        }
+        this.sendMessage({
+            "type": "KEEPALIVE",
+            "channel": 0
+        });
+    };
+    MarketDataStreamer.prototype.queueSubscription = function (symbol, options) {
+        var subscriptionTypes = options.subscriptionTypes, channelId = options.channelId, subscriptionArgs = options.subscriptionArgs;
+        var queue = this.subscriptionsQueue.get(options.channelId);
+        if (lodash_1.default.isNil(queue)) {
+            queue = [];
+            this.subscriptionsQueue.set(channelId, queue);
+        }
+        queue.push({ symbol: symbol, subscriptionTypes: subscriptionTypes, subscriptionArgs: subscriptionArgs });
+    };
+    MarketDataStreamer.prototype.dequeueSubscription = function (symbol, options) {
+        var queue = this.subscriptionsQueue.get(options.channelId);
+        if (lodash_1.default.isNil(queue) || lodash_1.default.isEmpty(queue)) {
+            return;
+        }
+        lodash_1.default.remove(queue, function (queueItem) { return queueItem.symbol === symbol; });
+    };
+    MarketDataStreamer.prototype.sendQueuedSubscriptions = function (channelId) {
+        var _this = this;
+        var queuedSubscriptions = this.subscriptionsQueue.get(channelId);
+        if (lodash_1.default.isNil(queuedSubscriptions)) {
+            return;
+        }
+        // Clear out queue immediately
+        this.subscriptionsQueue.set(channelId, []);
+        queuedSubscriptions.forEach(function (subscription) {
+            _this.sendSubscriptionMessage(subscription.symbol, subscription.subscriptionTypes, channelId, 'add', subscription.subscriptionArgs);
+        });
+    };
+    /**
+     *
+     * @param {*} symbol
+     * @param {*} subscriptionTypes
+     * @param {*} channelId
+     * @param {*} direction add or remove
+     */
+    MarketDataStreamer.prototype.sendSubscriptionMessage = function (symbol, subscriptionTypes, channelId, direction, subscriptionArgs) {
+        var _a;
+        if (subscriptionArgs === void 0) { subscriptionArgs = {}; }
+        var subscriptions = subscriptionTypes.map(function (type) { return (Object.assign({}, { "symbol": symbol, "type": type }, subscriptionArgs !== null && subscriptionArgs !== void 0 ? subscriptionArgs : {})); });
+        this.sendMessage((_a = {
+                "type": "FEED_SUBSCRIPTION",
+                "channel": channelId
+            },
+            _a[direction] = subscriptions,
+            _a));
+    };
+    MarketDataStreamer.prototype.onError = function (error) {
+        console.error('Error received: ', error);
+        this.notifyErrorListeners(error);
+    };
+    MarketDataStreamer.prototype.onOpen = function () {
+        this.openChannels.clear();
+        this.sendMessage({
+            "type": "SETUP",
+            "channel": 0,
+            "keepaliveTimeout": KeepaliveInterval,
+            "acceptKeepaliveTimeout": KeepaliveInterval,
+            "version": "0.1-js/1.0.0"
+        });
+        this.scheduleKeepalive();
+    };
+    MarketDataStreamer.prototype.onClose = function () {
+        this.webSocket = null;
+        this.clearKeepalive();
+    };
+    MarketDataStreamer.prototype.clearKeepalive = function () {
+        if (!lodash_1.default.isNil(this.keepaliveIntervalId)) {
+            clearInterval(this.keepaliveIntervalId);
+        }
+        this.keepaliveIntervalId = null;
+    };
+    Object.defineProperty(MarketDataStreamer.prototype, "isDxLinkAuthorized", {
+        get: function () {
+            return this.authState === 'AUTHORIZED';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MarketDataStreamer.prototype.handleAuthStateMessage = function (data) {
+        var _this = this;
+        this.authState = data.state;
+        this.authStateListeners.forEach(function (listener) { return listener(_this.isDxLinkAuthorized); });
+        if (this.isDxLinkAuthorized) {
+            this.openFeedChannel(DefaultChannelId);
+        }
+        else {
+            this.sendMessage({
+                "type": "AUTH",
+                "channel": 0,
+                "token": this.token
+            });
+        }
+    };
+    MarketDataStreamer.prototype.handleChannelOpened = function (jsonData) {
+        this.openChannels.add(jsonData.channel);
+        this.sendQueuedSubscriptions(jsonData.channel);
+    };
+    MarketDataStreamer.prototype.notifyListeners = function (jsonData) {
+        this.dataListeners.forEach(function (listenerData) {
+            if (listenerData.channelId === jsonData.channel || lodash_1.default.isNil(listenerData.channelId)) {
+                listenerData.listener(jsonData);
+            }
+        });
+    };
+    MarketDataStreamer.prototype.notifyErrorListeners = function (error) {
+        this.errorListeners.forEach(function (listener) { return listener(error); });
+    };
+    MarketDataStreamer.prototype.handleMessageReceived = function (data) {
+        var messageData = lodash_1.default.get(data, 'data', data);
+        var jsonData = JSON.parse(messageData);
+        switch (jsonData.type) {
+            case 'AUTH_STATE':
+                this.handleAuthStateMessage(jsonData);
+                break;
+            case 'CHANNEL_OPENED':
+                this.handleChannelOpened(jsonData);
+                break;
+            case 'FEED_DATA':
+                this.notifyListeners(jsonData);
+                break;
+        }
+    };
+    MarketDataStreamer.prototype.sendMessage = function (json) {
+        if (lodash_1.default.isNil(this.webSocket)) {
+            return;
+        }
+        this.webSocket.send(JSON.stringify(json));
+    };
+    return MarketDataStreamer;
+}());
+exports.default = MarketDataStreamer;

package/dist/services/accounts-and-customers-service.d.ts

@@ -6,5 +6,5 @@ export default class AccountsAndCustomersService {
     getCustomerResource(): Promise<any>;
     getCustomerAccountResources(): Promise<any>;
     getFullCustomerAccountResource(accountNumber: string): Promise<any>;
-    getQuoteStreamerTokens(): Promise<any>;
+    getApiQuoteToken(): Promise<any>;
 }

package/dist/services/accounts-and-customers-service.js

@@ -97,16 +97,16 @@ var AccountsAndCustomersService = /** @class */ (function () {
             });
         });
     };
-    //Quote-streamer-tokens: Operations about quote-streamer-tokens
-    AccountsAndCustomersService.prototype.getQuoteStreamerTokens = function () {
+    //Returns the appropriate quote streamer endpoint, level and identification token for the current customer to receive market data.
+    AccountsAndCustomersService.prototype.getApiQuoteToken = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var quoteStreamerTokens;
+            var apiQuoteToken;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.httpClient.getData('/quote-streamer-tokens', {}, {})];
+                    case 0: return [4 /*yield*/, this.httpClient.getData('/api-quote-tokens', {}, {})];
                     case 1:
-                        quoteStreamerTokens = (_a.sent());
-                        return [2 /*return*/, (0, response_util_1.default)(quoteStreamerTokens)];
+                        apiQuoteToken = (_a.sent());
+                        return [2 /*return*/, (0, response_util_1.default)(apiQuoteToken)];
                 }
             });
         });

package/dist/tastytrade-api.d.ts

@@ -1,6 +1,6 @@
 import TastytradeHttpClient from "./services/tastytrade-http-client";
 import { AccountStreamer, STREAMER_STATE, Disposer, StreamerStateObserver } from './account-streamer';
-import QuoteStreamer from "./quote-streamer";
+import MarketDataStreamer, { CandleSubscriptionOptions, CandleType, MarketDataSubscriptionType, MarketDataListener } from "./market-data-streamer";
 import SessionService from "./services/session-service";
 import AccountStatusService from "./services/account-status-service";
 import AccountsAndCustomersService from "./services/accounts-and-customers-service";
@@ -36,5 +36,5 @@ export default class TastytradeClient {
     constructor(baseUrl: string, accountStreamerUrl: string);
     get session(): TastytradeSession;
 }
-export { QuoteStreamer };
+export { MarketDataStreamer, MarketDataSubscriptionType, MarketDataListener, CandleSubscriptionOptions, CandleType };
 export { AccountStreamer, STREAMER_STATE, Disposer, StreamerStateObserver };

package/dist/tastytrade-api.js

@@ -1,15 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STREAMER_STATE = exports.AccountStreamer = exports.QuoteStreamer = void 0;
+exports.STREAMER_STATE = exports.AccountStreamer = exports.CandleType = exports.MarketDataSubscriptionType = exports.MarketDataStreamer = void 0;
 var tastytrade_http_client_1 = __importDefault(require("./services/tastytrade-http-client"));
 var account_streamer_1 = require("./account-streamer");
 Object.defineProperty(exports, "AccountStreamer", { enumerable: true, get: function () { return account_streamer_1.AccountStreamer; } });
 Object.defineProperty(exports, "STREAMER_STATE", { enumerable: true, get: function () { return account_streamer_1.STREAMER_STATE; } });
-var quote_streamer_1 = __importDefault(require("./quote-streamer"));
-exports.QuoteStreamer = quote_streamer_1.default;
+var market_data_streamer_1 = __importStar(require("./market-data-streamer"));
+exports.MarketDataStreamer = market_data_streamer_1.default;
+Object.defineProperty(exports, "CandleType", { enumerable: true, get: function () { return market_data_streamer_1.CandleType; } });
+Object.defineProperty(exports, "MarketDataSubscriptionType", { enumerable: true, get: function () { return market_data_streamer_1.MarketDataSubscriptionType; } });
 //Services:
 var session_service_1 = __importDefault(require("./services/session-service"));
 var account_status_service_1 = __importDefault(require("./services/account-status-service"));

package/lib/market-data-streamer.ts

@@ -0,0 +1,369 @@
+import WebSocket from 'isomorphic-ws'
+import _ from 'lodash'
+import { v4 as uuidv4 } from 'uuid'
+
+export enum MarketDataSubscriptionType {
+  Candle = 'Candle',
+  Quote = 'Quote',
+  Trade = 'Trade',
+  Summary = 'Summary',
+  Profile = 'Profile',
+  Greeks = 'Greeks',
+  Underlying = 'Underlying'
+}
+
+export enum CandleType {
+  Tick = 't',
+  Second = 's',
+  Minute = 'm',
+  Hour = 'h',
+  Day = 'd',
+  Week = 'w',
+  Month = 'mo',
+  ThirdFriday = 'o',
+  Year = 'y',
+  Volume = 'v',
+  Price = 'p'
+}
+
+export type MarketDataListener = (data: any) => void
+export type ErrorListener = (error: any) => void
+export type AuthStateListener = (isAuthorized: boolean) => void
+
+type QueuedSubscription = { symbol: string, subscriptionTypes: MarketDataSubscriptionType[], subscriptionArgs?: any }
+type SubscriptionOptions = { subscriptionTypes: MarketDataSubscriptionType[], channelId: number, subscriptionArgs?: any }
+export type CandleSubscriptionOptions = { period: number, type: CandleType, channelId: number }
+type Remover = () => void
+
+// List of all subscription types except for Candle
+const AllSubscriptionTypes = Object.values(MarketDataSubscriptionType)
+
+const KeepaliveInterval = 30000 // 30 seconds
+
+const DefaultChannelId = 1
+
+export default class MarketDataStreamer {
+  private webSocket: WebSocket | null = null
+  private token = ''
+  private keepaliveIntervalId: any | null = null
+  private dataListeners = new Map()
+  private openChannels = new Set()
+  private subscriptionsQueue: Map<number, QueuedSubscription[]> = new Map()
+  private authState = ''
+  private errorListeners = new Map()
+  private authStateListeners = new Map()
+
+  addDataListener(dataListener: MarketDataListener, channelId: number | null = null): Remover {
+    if (_.isNil(dataListener)) {
+      return _.noop
+    }
+    const guid = uuidv4()
+    this.dataListeners.set(guid, { listener: dataListener, channelId })
+
+    return () => this.dataListeners.delete(guid)
+  }
+
+  addErrorListener(errorListener: ErrorListener): Remover {
+    if (_.isNil(errorListener)) {
+      return _.noop
+    }
+    const guid = uuidv4()
+    this.errorListeners.set(guid, errorListener)
+
+    return () => this.errorListeners.delete(guid)
+  }
+
+  addAuthStateChangeListener(authStateListener: AuthStateListener): Remover {
+    if (_.isNil(authStateListener)) {
+      return _.noop
+    }
+    const guid = uuidv4()
+    this.authStateListeners.set(guid, authStateListener)
+
+    return () => this.authStateListeners.delete(guid)
+  }
+
+  connect(url: string, token: string) {
+    if (this.isConnected) {
+      throw new Error('MarketDataStreamer is attempting to connect when an existing websocket is already connected')
+    }
+
+    this.token = token
+    this.webSocket = new WebSocket(url)
+    this.webSocket.onopen = this.onOpen.bind(this)
+    this.webSocket.onerror = this.onError.bind(this)
+    this.webSocket.onmessage = this.handleMessageReceived.bind(this)
+    this.webSocket.onclose = this.onClose.bind(this)
+  }
+
+  disconnect() {
+    if (_.isNil(this.webSocket)) {
+      return
+    }
+
+    this.clearKeepalive()
+
+    this.webSocket.onopen = null
+    this.webSocket.onerror = null
+    this.webSocket.onmessage = null
+    this.webSocket.onclose = null
+
+    this.webSocket.close()
+    this.webSocket = null
+
+    this.openChannels.clear()
+    this.subscriptionsQueue.clear()
+    this.authState = ''
+  }
+
+  addSubscription(symbol: string, options = { subscriptionTypes: AllSubscriptionTypes, channelId: DefaultChannelId }): Remover {
+    let { subscriptionTypes } = options
+    // Don't allow candle subscriptions in this method. Use addCandleSubscription instead
+    subscriptionTypes = _.without(subscriptionTypes, MarketDataSubscriptionType.Candle)
+
+    const isOpen = this.isChannelOpened(options.channelId)
+    if (isOpen) {
+      this.sendSubscriptionMessage(symbol, subscriptionTypes, options.channelId, 'add')
+    } else {
+      this.queueSubscription(symbol, { subscriptionTypes, channelId: options.channelId })
+    }
+
+    return () => {
+      this.removeSubscription(symbol, options)
+    }
+  }
+
+  /**
+   * Adds a candle subscription (historical data)
+   * @param streamerSymbol Get this from an instrument's streamer-symbol json response field
+   * @param fromTime Epoch timestamp from where you want to start
+   * @param options Period and Type are the grouping you want to apply to the candle data
+   * For example, a period/type of 5/m means you want each candle to represent 5 minutes of data
+   * From there, setting fromTime to 24 hours ago would give you 24 hours of data grouped in 5 minute intervals
+   * @returns 
+   */
+  addCandleSubscription(streamerSymbol: string, fromTime: number, options: CandleSubscriptionOptions) {
+    const subscriptionTypes = [MarketDataSubscriptionType.Candle]
+    const channelId = options.channelId ?? DefaultChannelId
+
+    // Example: AAPL{=5m} where each candle represents 5 minutes of data
+    const candleSymbol = `${streamerSymbol}{=${options.period}${options.type}}`
+    const isOpen = this.isChannelOpened(channelId)
+    const subscriptionArgs = { fromTime }
+    if (isOpen) {
+      this.sendSubscriptionMessage(candleSymbol, subscriptionTypes, channelId, 'add', subscriptionArgs)
+    } else {
+      this.queueSubscription(candleSymbol, { subscriptionTypes, channelId, subscriptionArgs })
+    }
+
+    return () => {
+      this.removeSubscription(candleSymbol, { subscriptionTypes, channelId })
+    }
+  }
+
+  removeSubscription(symbol: string, options = { subscriptionTypes: AllSubscriptionTypes, channelId: DefaultChannelId }) {
+    const { subscriptionTypes, channelId } = options
+    const isOpen = this.isChannelOpened(channelId)
+    if (isOpen) {
+      this.sendSubscriptionMessage(symbol, subscriptionTypes, channelId, 'remove')
+    } else {
+      this.dequeueSubscription(symbol, options)
+    }
+  }
+
+  removeAllSubscriptions(channelId = DefaultChannelId) {
+    const isOpen = this.isChannelOpened(channelId)
+    if (isOpen) {
+      this.sendMessage({ "type": "FEED_SUBSCRIPTION", "channel": channelId, reset: true })
+    } else {
+      this.subscriptionsQueue.set(channelId, [])
+    }
+  }
+
+  openFeedChannel(channelId: number) {
+    if (!this.isReadyToOpenChannels) {
+      throw new Error(`Unable to open channel ${channelId} due to DxLink authorization state: ${this.authState}`)
+    }
+
+    if (this.isChannelOpened(channelId)) {
+      return
+    }
+
+    this.sendMessage({
+      "type": "CHANNEL_REQUEST",
+      "channel": channelId,
+      "service": "FEED",
+      "parameters": {
+        "contract": "AUTO"
+      }
+    })
+  }
+
+  isChannelOpened(channelId: number) {
+    return this.isConnected && this.openChannels.has(channelId)
+  }
+
+  get isReadyToOpenChannels() {
+    return this.isConnected && this.isDxLinkAuthorized
+  }
+
+  get isConnected() {
+    return !_.isNil(this.webSocket)
+  }
+
+  private scheduleKeepalive() {
+    this.keepaliveIntervalId = setInterval(this.sendKeepalive, KeepaliveInterval)
+  }
+
+  private sendKeepalive() {
+    if (_.isNil(this.keepaliveIntervalId)) {
+      return
+    }
+
+    this.sendMessage({
+      "type": "KEEPALIVE",
+      "channel": 0
+    })
+  }
+
+  private queueSubscription(symbol: string, options: SubscriptionOptions) {
+    const { subscriptionTypes, channelId, subscriptionArgs } = options
+    let queue = this.subscriptionsQueue.get(options.channelId)
+    if (_.isNil(queue)) {
+      queue = []
+      this.subscriptionsQueue.set(channelId, queue)
+    }
+    
+    queue.push({ symbol, subscriptionTypes, subscriptionArgs })
+  }
+
+  private dequeueSubscription(symbol: string, options: SubscriptionOptions) {
+    const queue = this.subscriptionsQueue.get(options.channelId)
+    if (_.isNil(queue) || _.isEmpty(queue)) {
+      return
+    }
+
+    _.remove(queue, (queueItem: any) => queueItem.symbol === symbol)
+  }
+
+  private sendQueuedSubscriptions(channelId: number) {
+    const queuedSubscriptions = this.subscriptionsQueue.get(channelId)
+    if (_.isNil(queuedSubscriptions)) {
+      return
+    }
+
+    // Clear out queue immediately
+    this.subscriptionsQueue.set(channelId, [])
+    queuedSubscriptions.forEach(subscription => {
+      this.sendSubscriptionMessage(subscription.symbol, subscription.subscriptionTypes, channelId, 'add', subscription.subscriptionArgs)
+    })
+  }
+
+  /**
+   * 
+   * @param {*} symbol 
+   * @param {*} subscriptionTypes 
+   * @param {*} channelId 
+   * @param {*} direction add or remove
+   */
+  private sendSubscriptionMessage(symbol: string, subscriptionTypes: MarketDataSubscriptionType[], channelId: number, direction: string, subscriptionArgs: any = {}) {
+    const subscriptions = subscriptionTypes.map(type => (Object.assign({}, { "symbol": symbol, "type": type }, subscriptionArgs ?? {})))
+    this.sendMessage({
+      "type": "FEED_SUBSCRIPTION",
+      "channel": channelId,
+      [direction]: subscriptions
+    })
+  }
+
+  private onError(error: any) {
+    console.error('Error received: ', error)
+    this.notifyErrorListeners(error)
+  }
+
+  private onOpen() {
+    this.openChannels.clear()
+
+    this.sendMessage({
+      "type": "SETUP",
+      "channel": 0,
+      "keepaliveTimeout": KeepaliveInterval,
+      "acceptKeepaliveTimeout": KeepaliveInterval,
+      "version": "0.1-js/1.0.0"
+    })
+
+    this.scheduleKeepalive()
+  }
+
+  private onClose() {
+    this.webSocket = null
+    this.clearKeepalive()
+  }
+
+  private clearKeepalive() {
+    if (!_.isNil(this.keepaliveIntervalId)) {
+      clearInterval(this.keepaliveIntervalId)
+    }
+
+    this.keepaliveIntervalId = null
+  }
+
+  get isDxLinkAuthorized() {
+    return this.authState === 'AUTHORIZED'
+  }
+
+  private handleAuthStateMessage(data: any) {
+    this.authState = data.state
+    this.authStateListeners.forEach(listener => listener(this.isDxLinkAuthorized))
+
+    if (this.isDxLinkAuthorized) {
+      this.openFeedChannel(DefaultChannelId)
+    } else {
+      this.sendMessage({
+        "type": "AUTH",
+        "channel": 0,
+        "token": this.token
+      })
+    }
+  }
+
+  private handleChannelOpened(jsonData: any) {
+    this.openChannels.add(jsonData.channel)
+    this.sendQueuedSubscriptions(jsonData.channel)
+  }
+
+  private notifyListeners(jsonData: any) {
+    this.dataListeners.forEach(listenerData => {
+      if (listenerData.channelId === jsonData.channel || _.isNil(listenerData.channelId)) {
+        listenerData.listener(jsonData)
+      }
+    })
+  }
+
+  private notifyErrorListeners(error: any) {
+    this.errorListeners.forEach(listener => listener(error))
+  }
+
+  private handleMessageReceived(data: string) {
+    const messageData = _.get(data, 'data', data)
+    const jsonData = JSON.parse(messageData)
+    switch (jsonData.type) {
+      case 'AUTH_STATE':
+        this.handleAuthStateMessage(jsonData)
+        break
+      case 'CHANNEL_OPENED':
+        this.handleChannelOpened(jsonData)
+        break
+      case 'FEED_DATA':
+        this.notifyListeners(jsonData)
+        break
+    }
+  }
+
+  private sendMessage(json: object) {
+    if (_.isNil(this.webSocket)) {
+      return
+    }
+
+    this.webSocket.send(JSON.stringify(json))
+  }
+}

package/lib/services/accounts-and-customers-service.ts

@@ -26,10 +26,9 @@ export default class AccountsAndCustomersService {
         return extractResponseData(fullCustomerAccountResource)
     }
 
-    //Quote-streamer-tokens: Operations about quote-streamer-tokens
-    async getQuoteStreamerTokens(){
-        //Returns the appropriate quote streamer endpoint, level and identification token for the current customer to receive market data.
-        const quoteStreamerTokens = (await this.httpClient.getData('/quote-streamer-tokens', {}, {}))
-        return extractResponseData(quoteStreamerTokens)
+    //Returns the appropriate quote streamer endpoint, level and identification token for the current customer to receive market data.
+    async getApiQuoteToken() {
+        const apiQuoteToken = (await this.httpClient.getData('/api-quote-tokens', {}, {}))
+        return extractResponseData(apiQuoteToken)
     }
 }

package/lib/tastytrade-api.ts

@@ -1,6 +1,6 @@
 import TastytradeHttpClient from "./services/tastytrade-http-client"
 import { AccountStreamer, STREAMER_STATE, Disposer, StreamerStateObserver } from './account-streamer'
-import QuoteStreamer from "./quote-streamer"
+import MarketDataStreamer, { CandleSubscriptionOptions, CandleType, MarketDataSubscriptionType, MarketDataListener } from "./market-data-streamer"
 
 //Services:
 import SessionService from "./services/session-service"
@@ -61,5 +61,5 @@ export default class TastytradeClient {
   }
 }
 
-export { QuoteStreamer }
+export { MarketDataStreamer, MarketDataSubscriptionType, MarketDataListener, CandleSubscriptionOptions, CandleType }
 export { AccountStreamer, STREAMER_STATE, Disposer, StreamerStateObserver }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tastytrade/api",
-  "version": "1.0.0",
+  "version": "2.1.0",
   "main": "dist/tastytrade-api.js",
   "typings": "dist/tastytrade-api.d.ts",
   "repository": "https://github.com/tastytrade/tastytrade-api-js",
@@ -11,19 +11,24 @@
     "test": "jest -i --restoreMocks",
     "unit-test": "jest --testPathPattern=tests/unit",
     "integration-test": "jest --testPathPattern=tests/integration",
-    "lint": "eslint lib/** tests/**"
+    "lint": "eslint lib/** tests/**",
+    "prepublishOnly": "npm run test && npm run build",
+    "postpack": "git tag -a $npm_package_version -m $npm_package_version && git push origin $npm_package_version"
   },
   "dependencies": {
-    "@dxfeed/api": "^1.1.0",
     "@types/lodash": "^4.14.182",
     "@types/qs": "^6.9.7",
     "axios": "^1.3.4",
+    "isomorphic-ws": "^5.0.0",
     "lodash": "^4.17.21",
-    "qs": "^6.11.1"
+    "qs": "^6.11.1",
+    "uuid": "^9.0.0",
+    "ws": "^8.13.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.0",
     "@types/node": "17.0.27",
+    "@types/uuid": "^9.0.2",
     "@typescript-eslint/eslint-plugin": "^5.57.1",
     "@typescript-eslint/parser": "^5.57.1",
     "dotenv": "^16.0.3",

package/lib/quote-streamer.ts

@@ -1,40 +0,0 @@
-import Feed, { EventType, IEvent } from '@dxfeed/api'
-import _ from 'lodash'
-
-export const SupportedEventTypes = [
-  EventType.Quote,
-  EventType.Trade,
-  EventType.Summary,
-  EventType.Greeks,
-  EventType.Profile
-]
-
-export default class QuoteStreamer {
-  private feed: Feed | null = null
-
-  constructor(private readonly token: string, private readonly url: string) {}
-
-  connect() {
-    this.feed = new Feed()
-    this.feed.setAuthToken(this.token)
-    this.feed.connect(this.url)
-  }
-
-  disconnect() {
-    if (!_.isNil(this.feed)) {
-      this.feed.disconnect()
-    }
-  }
-
-  subscribe(dxfeedSymbol: string, eventHandler: (event: IEvent) => void): () => void {
-    if (_.isNil(this.feed)) {
-      return _.noop
-    }
-
-    return this.feed.subscribe(
-      SupportedEventTypes,
-      [dxfeedSymbol],
-      eventHandler
-    )
-  }
-}