firstock 1.0.8 → 1.0.9

package/dist/Classes/AFirstock.d.ts

@@ -229,5 +229,35 @@ declare abstract class AFirstock {
     abstract getExpiry(params: GetExpiryParams, callBack: (error: Error | string | null, result: Response | null) => void): void;
     abstract brokerageCalculator(params: BrokerageCalculatorParams, callBack: (error: Error | string | null, result: Response | null) => void): void;
     abstract getHoldingsDetails(params: GetHoldingsParams, callBack: (error: Error | null, result: Response | null) => void): void;
+    abstract initializeWebsockets(userId: string, model: any, config?: any): Promise<[any | null, {
+        error: {
+            message: string;
+        };
+    } | null]>;
+    abstract closeWebsocket(ws: any | null): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    abstract subscribe(ws: any | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    abstract unsubscribe(ws: any | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    abstract subscribeOptionGreeks(ws: any | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    abstract unsubscribeOptionGreeks(ws: any | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
 }
 export default AFirstock;

package/dist/Classes/Firstock.d.ts

@@ -1,4 +1,7 @@
+import WebSocket from "ws";
 import AFirstock from "./AFirstock";
+import { FirstockWebSocket } from "../websockets/websockets";
+import { Config } from "../websockets/websocket_functions";
 interface Response {
     data: {
         [key: string]: any;
@@ -932,5 +935,84 @@ export declare class Firstock extends AFirstock {
      * - `result`: Parsed response containing holdings information if successful.
      */
     getHoldingsDetails({ userId }: GetHoldingsParams, callBack: (error: Error | null, result: Response | null) => void): void;
+    /**
+     * Initializes a WebSocket connection to Firstock for real-time market data streaming.
+     *
+     * @param {string} userId - The user ID for authentication.
+     * @param {FirstockWebSocket} model - WebSocket model containing tokens and subscriptions.
+     * @param {Config} [config] - Optional configuration for WebSocket connection.
+     * @returns {Promise<[WebSocket | null, { error: { message: string } } | null]>}
+     *          A promise that resolves to a tuple containing the WebSocket instance (or null on error)
+     *          and an error object (or null on success).
+     */
+    initializeWebsockets(userId: string, model: FirstockWebSocket, config?: Config): Promise<[WebSocket | null, {
+        error: {
+            message: string;
+        };
+    } | null]>;
+    /**
+     * Closes an active WebSocket connection.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance to close.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object if closure fails, or null on success.
+     */
+    closeWebsocket(ws: WebSocket | null): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    /**
+     * Subscribes to market data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of token strings to subscribe to.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    subscribe(ws: WebSocket | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    /**
+     * Unsubscribes from market data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of token strings to unsubscribe from.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    unsubscribe(ws: WebSocket | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    /**
+     * Subscribes to option Greeks data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of option token strings to subscribe to.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    subscribeOptionGreeks(ws: WebSocket | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    /**
+     * Unsubscribes from option Greeks data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of option token strings to unsubscribe from.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    unsubscribeOptionGreeks(ws: WebSocket | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
 }
 export {};

package/dist/Classes/Firstock.js

@@ -32,6 +32,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -39,9 +48,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Firstock = void 0;
 const axios_1 = __importDefault(require("axios"));
 const sha256 = __importStar(require("sha256"));
+const ws_1 = __importDefault(require("ws"));
 const AFirstock_1 = __importDefault(require("./AFirstock"));
 const commonFunction_1 = require("../shared/commonFunction");
 const constant_1 = require("../shared/constant");
+const websocket_functions_1 = require("../websockets/websocket_functions");
+// interface Config {
+//   scheme?: string;
+//   host?: string;
+//   path?: string;
+//   source?: string;
+//   accept_encoding?: string;
+//   accept_language?: string;
+//   origin?: string;
+//   max_websocket_connection_retries?: number;
+//   time_interval?: number;
+//   [key: string]: any;
+// }
 const axiosInterceptor = axios_1.default.create({
     baseURL: constant_1.API_LINK,
 });
@@ -1821,5 +1844,209 @@ class Firstock extends AFirstock_1.default {
             }
         });
     }
+    // WebSocket methods
+    /**
+     * Initializes a WebSocket connection to Firstock for real-time market data streaming.
+     *
+     * @param {string} userId - The user ID for authentication.
+     * @param {FirstockWebSocket} model - WebSocket model containing tokens and subscriptions.
+     * @param {Config} [config] - Optional configuration for WebSocket connection.
+     * @returns {Promise<[WebSocket | null, { error: { message: string } } | null]>}
+     *          A promise that resolves to a tuple containing the WebSocket instance (or null on error)
+     *          and an error object (or null on success).
+     */
+    initializeWebsockets(userId, model, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const finalConfig = Object.assign({ scheme: 'wss', host: 'socket.firstock.in', path: '/ws', source: 'developer-api', accept_encoding: 'gzip, deflate, br', accept_language: 'en-US,en;q=0.9', origin: 'https://firstock.in', max_websocket_connection_retries: 3, time_interval: 5 }, config);
+            const [baseUrl, headers, err] = (0, websocket_functions_1.getUrlAndHeaderData)(userId, finalConfig);
+            if (err) {
+                return [null, { error: { message: err.message } }];
+            }
+            try {
+                const ws = new ws_1.default(baseUrl, { headers });
+                yield new Promise((resolve, reject) => {
+                    const timeout = setTimeout(() => {
+                        reject(new Error('Connection timeout'));
+                    }, 10000);
+                    ws.once('open', () => {
+                        clearTimeout(timeout);
+                        resolve();
+                    });
+                    ws.once('error', (error) => {
+                        clearTimeout(timeout);
+                        reject(error);
+                    });
+                });
+                yield websocket_functions_1.connections.addConnection(ws);
+                const msg = yield new Promise((resolve, reject) => {
+                    const timeout = setTimeout(() => {
+                        reject(new Error('Authentication timeout'));
+                    }, 5000);
+                    ws.once('message', (data) => {
+                        clearTimeout(timeout);
+                        resolve(data.toString());
+                    });
+                    ws.once('error', (error) => {
+                        clearTimeout(timeout);
+                        reject(error);
+                    });
+                });
+                if (msg.includes("Authentication successful")) {
+                    yield new Promise(resolve => setTimeout(resolve, 500));
+                    const modelDict = model.toDict();
+                    (0, websocket_functions_1.readMessage)(userId, ws, modelDict, finalConfig);
+                    yield new Promise(resolve => setTimeout(resolve, 500));
+                    if (model.tokens && model.tokens.length > 0) {
+                        const subscribeErr = yield (0, websocket_functions_1.subscribe)(ws, model.tokens);
+                        if (subscribeErr) {
+                        }
+                    }
+                    if (model.option_greeks_tokens && model.option_greeks_tokens.length > 0) {
+                        const subscribeErr = yield (0, websocket_functions_1.subscribeOptionGreeks)(ws, model.option_greeks_tokens);
+                        if (subscribeErr) {
+                        }
+                    }
+                    return [ws, null];
+                }
+                else if (msg.includes("Maximum sessions limit")) {
+                    yield websocket_functions_1.connections.deleteConnection(ws);
+                    return [null, { error: { message: msg } }];
+                }
+                else {
+                    yield websocket_functions_1.connections.deleteConnection(ws);
+                    return [null, { error: { message: `Unexpected authentication response: ${msg}` } }];
+                }
+            }
+            catch (e) {
+                return [null, { error: { message: e.message } }];
+            }
+        });
+    }
+    /**
+     * Closes an active WebSocket connection.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance to close.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object if closure fails, or null on success.
+     */
+    closeWebsocket(ws) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ws === null) {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+            if (yield websocket_functions_1.connections.checkIfConnectionExists(ws)) {
+                try {
+                    ws.close();
+                    yield websocket_functions_1.connections.deleteConnection(ws);
+                    return null;
+                }
+                catch (e) {
+                    const errorMsg = e.message.toLowerCase();
+                    if (!errorMsg.includes("closed")) {
+                        return {
+                            error: {
+                                message: e.message
+                            }
+                        };
+                    }
+                    else {
+                        yield websocket_functions_1.connections.deleteConnection(ws);
+                        return null;
+                    }
+                }
+            }
+            else {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+        });
+    }
+    /**
+     * Subscribes to market data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of token strings to subscribe to.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    subscribe(ws, tokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ws === null) {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+            return (0, websocket_functions_1.subscribe)(ws, tokens);
+        });
+    }
+    /**
+     * Unsubscribes from market data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of token strings to unsubscribe from.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    unsubscribe(ws, tokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ws === null) {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+            return (0, websocket_functions_1.unsubscribe)(ws, tokens);
+        });
+    }
+    /**
+     * Subscribes to option Greeks data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of option token strings to subscribe to.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    subscribeOptionGreeks(ws, tokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ws === null) {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+            return (0, websocket_functions_1.subscribeOptionGreeks)(ws, tokens);
+        });
+    }
+    /**
+     * Unsubscribes from option Greeks data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of option token strings to unsubscribe from.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    unsubscribeOptionGreeks(ws, tokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ws === null) {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+            return (0, websocket_functions_1.unsubscribeOptionGreeks)(ws, tokens);
+        });
+    }
 }
 exports.Firstock = Firstock;

package/dist/test.js

@@ -7,11 +7,11 @@ const index_1 = __importDefault(require("./index"));
 const firstock = new index_1.default();
 let orderNumber = "";
 const userDetails = {
-    userId: "NP2997",
-    password: "Skanda@2025",
-    TOTP: "1997",
-    vendorCode: "NP2997_API",
-    apiKey: "e55eb28e18ee1337fc0b2705f9b82465",
+    userId: "CM2096",
+    password: "Leaveme@L0ne",
+    TOTP: "1996",
+    vendorCode: "FIRSTOCK_MST_KEY",
+    apiKey: "Nco@MS7K8t",
 };
 // const userDetails = {
 //   userId: "",

package/dist/websockets/websockets.d.ts

@@ -1,5 +1,5 @@
 import WebSocket from 'ws';
-import { Config, WebSocketModel } from './websocket_functions';
+import { WebSocketModel } from './websocket_functions';
 export declare class FirstockWebSocket {
     tokens?: string[];
     option_greeks_tokens?: string[];
@@ -19,35 +19,3 @@ export declare class FirstockWebSocket {
     });
     toDict(): WebSocketModel;
 }
-export declare class Firstock {
-    static initializeWebsockets(userId: string, model: FirstockWebSocket, config?: Config): Promise<[WebSocket | null, {
-        error: {
-            message: string;
-        };
-    } | null]>;
-    static closeWebsocket(ws: WebSocket | null): Promise<{
-        error: {
-            message: string;
-        };
-    } | null>;
-    static subscribe(ws: WebSocket | null, tokens: string[]): Promise<{
-        error: {
-            message: string;
-        };
-    } | null>;
-    static unsubscribe(ws: WebSocket | null, tokens: string[]): Promise<{
-        error: {
-            message: string;
-        };
-    } | null>;
-    static subscribeOptionGreeks(ws: WebSocket | null, tokens: string[]): Promise<{
-        error: {
-            message: string;
-        };
-    } | null>;
-    static unsubscribeOptionGreeks(ws: WebSocket | null, tokens: string[]): Promise<{
-        error: {
-            message: string;
-        };
-    } | null>;
-}

package/dist/websockets/websockets.js

@@ -1,20 +1,6 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Firstock = exports.FirstockWebSocket = void 0;
-const ws_1 = __importDefault(require("ws"));
-const websocket_functions_1 = require("./websocket_functions");
+exports.FirstockWebSocket = void 0;
 const logger = {
     info: (msg) => console.info(`[INFO] ${new Date().toISOString()} - ${msg}`),
     error: (msg, err) => {
@@ -46,168 +32,176 @@ class FirstockWebSocket {
     }
 }
 exports.FirstockWebSocket = FirstockWebSocket;
-class Firstock {
-    static initializeWebsockets(userId, model, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const finalConfig = Object.assign({ scheme: 'wss', host: 'socket.firstock.in', path: '/ws', source: 'developer-api', accept_encoding: 'gzip, deflate, br', accept_language: 'en-US,en;q=0.9', origin: 'https://firstock.in', max_websocket_connection_retries: 3, time_interval: 5 }, config);
-            const [baseUrl, headers, err] = (0, websocket_functions_1.getUrlAndHeaderData)(userId, finalConfig);
-            if (err) {
-                return [null, { error: { message: err.message } }];
-            }
-            try {
-                const ws = new ws_1.default(baseUrl, { headers });
-                yield new Promise((resolve, reject) => {
-                    const timeout = setTimeout(() => {
-                        reject(new Error('Connection timeout'));
-                    }, 10000);
-                    ws.once('open', () => {
-                        clearTimeout(timeout);
-                        resolve();
-                    });
-                    ws.once('error', (error) => {
-                        clearTimeout(timeout);
-                        reject(error);
-                    });
-                });
-                logger.info("WebSocket connection created");
-                yield websocket_functions_1.connections.addConnection(ws);
-                const msg = yield new Promise((resolve, reject) => {
-                    const timeout = setTimeout(() => {
-                        reject(new Error('Authentication timeout'));
-                    }, 5000);
-                    ws.once('message', (data) => {
-                        clearTimeout(timeout);
-                        resolve(data.toString());
-                    });
-                    ws.once('error', (error) => {
-                        clearTimeout(timeout);
-                        reject(error);
-                    });
-                });
-                logger.info(`Initial message received: ${msg}`);
-                if (msg.includes("Authentication successful")) {
-                    logger.info("Authentication successful, starting message reader");
-                    yield new Promise(resolve => setTimeout(resolve, 500));
-                    const modelDict = model.toDict();
-                    (0, websocket_functions_1.readMessage)(userId, ws, modelDict, finalConfig);
-                    yield new Promise(resolve => setTimeout(resolve, 500));
-                    if (model.tokens && model.tokens.length > 0) {
-                        logger.info(`Subscribing to initial tokens: ${model.tokens.join(', ')}`);
-                        const subscribeErr = yield (0, websocket_functions_1.subscribe)(ws, model.tokens);
-                        if (subscribeErr) {
-                            logger.error(`Initial subscription error: ${JSON.stringify(subscribeErr)}`);
-                        }
-                    }
-                    if (model.option_greeks_tokens && model.option_greeks_tokens.length > 0) {
-                        logger.info(`Subscribing to option Greeks tokens: ${model.option_greeks_tokens.join(', ')}`);
-                        const subscribeErr = yield (0, websocket_functions_1.subscribeOptionGreeks)(ws, model.option_greeks_tokens);
-                        if (subscribeErr) {
-                            logger.error(`Initial option Greeks subscription error: ${JSON.stringify(subscribeErr)}`);
-                        }
-                    }
-                    return [ws, null];
-                }
-                else if (msg.includes("Maximum sessions limit")) {
-                    yield websocket_functions_1.connections.deleteConnection(ws);
-                    return [null, { error: { message: msg } }];
-                }
-                else {
-                    yield websocket_functions_1.connections.deleteConnection(ws);
-                    return [null, { error: { message: `Unexpected authentication response: ${msg}` } }];
-                }
-            }
-            catch (e) {
-                logger.error(`WebSocket initialization error: ${e.message}`, e);
-                return [null, { error: { message: e.message } }];
-            }
-        });
-    }
-    static closeWebsocket(ws) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (ws === null) {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-            if (yield websocket_functions_1.connections.checkIfConnectionExists(ws)) {
-                try {
-                    ws.close();
-                    yield websocket_functions_1.connections.deleteConnection(ws);
-                    return null;
-                }
-                catch (e) {
-                    const errorMsg = e.message.toLowerCase();
-                    if (!errorMsg.includes("closed")) {
-                        return {
-                            error: {
-                                message: e.message
-                            }
-                        };
-                    }
-                    else {
-                        yield websocket_functions_1.connections.deleteConnection(ws);
-                        return null;
-                    }
-                }
-            }
-            else {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-        });
-    }
-    static subscribe(ws, tokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (ws === null) {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-            return (0, websocket_functions_1.subscribe)(ws, tokens);
-        });
-    }
-    static unsubscribe(ws, tokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (ws === null) {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-            return (0, websocket_functions_1.unsubscribe)(ws, tokens);
-        });
-    }
-    static subscribeOptionGreeks(ws, tokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (ws === null) {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-            return (0, websocket_functions_1.subscribeOptionGreeks)(ws, tokens);
-        });
-    }
-    static unsubscribeOptionGreeks(ws, tokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (ws === null) {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-            return (0, websocket_functions_1.unsubscribeOptionGreeks)(ws, tokens);
-        });
-    }
-}
-exports.Firstock = Firstock;
+// export class Firstock {
+//     static async initializeWebsockets(
+//         userId: string,
+//         model: FirstockWebSocket,
+//         config?: Config
+//     ): Promise<[WebSocket | null, { error: { message: string } } | null]> {
+//         const finalConfig: Config = {
+//             scheme: 'wss',
+//             host: 'socket.firstock.in',
+//             path: '/ws',
+//             source: 'developer-api',
+//             accept_encoding: 'gzip, deflate, br',
+//             accept_language: 'en-US,en;q=0.9',
+//             origin: 'https://firstock.in',
+//             max_websocket_connection_retries: 3,
+//             time_interval: 5,
+//             ...config
+//         };
+//         const [baseUrl, headers, err] = getUrlAndHeaderData(userId, finalConfig);
+//         if (err) {
+//             return [null, { error: { message: err.message } }];
+//         }
+//         try {
+//             const ws = new WebSocket(baseUrl, { headers });
+//             await new Promise<void>((resolve, reject) => {
+//                 const timeout = setTimeout(() => {
+//                     reject(new Error('Connection timeout'));
+//                 }, 10000);
+//                 ws.once('open', () => {
+//                     clearTimeout(timeout);
+//                     resolve();
+//                 });
+//                 ws.once('error', (error) => {
+//                     clearTimeout(timeout);
+//                     reject(error);
+//                 });
+//             });
+//             logger.info("WebSocket connection created");
+//             await connections.addConnection(ws);
+//             const msg = await new Promise<string>((resolve, reject) => {
+//                 const timeout = setTimeout(() => {
+//                     reject(new Error('Authentication timeout'));
+//                 }, 5000);
+//                 ws.once('message', (data) => {
+//                     clearTimeout(timeout);
+//                     resolve(data.toString());
+//                 });
+//                 ws.once('error', (error) => {
+//                     clearTimeout(timeout);
+//                     reject(error);
+//                 });
+//             });
+//             logger.info(`Initial message received: ${msg}`);
+//             if (msg.includes("Authentication successful")) {
+//                 logger.info("Authentication successful, starting message reader");
+//                 await new Promise(resolve => setTimeout(resolve, 500));
+//                 const modelDict = model.toDict();
+//                 readMessage(userId, ws, modelDict, finalConfig);
+//                 await new Promise(resolve => setTimeout(resolve, 500));
+//                 if (model.tokens && model.tokens.length > 0) {
+//                     logger.info(`Subscribing to initial tokens: ${model.tokens.join(', ')}`);
+//                     const subscribeErr = await subscribeHelper(ws, model.tokens);
+//                     if (subscribeErr) {
+//                         logger.error(`Initial subscription error: ${JSON.stringify(subscribeErr)}`);
+//                     }
+//                 }
+//                 if (model.option_greeks_tokens && model.option_greeks_tokens.length > 0) {
+//                     logger.info(`Subscribing to option Greeks tokens: ${model.option_greeks_tokens.join(', ')}`);
+//                     const subscribeErr = await subscribeOptionGreeksHelper(ws, model.option_greeks_tokens);
+//                     if (subscribeErr) {
+//                         logger.error(`Initial option Greeks subscription error: ${JSON.stringify(subscribeErr)}`);
+//                     }
+//                 }
+//                 return [ws, null];
+//             } else if (msg.includes("Maximum sessions limit")) {
+//                 await connections.deleteConnection(ws);
+//                 return [null, { error: { message: msg } }];
+//             } else {
+//                 await connections.deleteConnection(ws);
+//                 return [null, { error: { message: `Unexpected authentication response: ${msg}` } }];
+//             }
+//         } catch (e) {
+//             logger.error(`WebSocket initialization error: ${(e as Error).message}`, e as Error);
+//             return [null, { error: { message: (e as Error).message } }];
+//         }
+//     }
+//     static async closeWebsocket(ws: WebSocket | null): Promise<{ error: { message: string } } | null> {
+//         if (ws === null) {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//         if (await connections.checkIfConnectionExists(ws)) {
+//             try {
+//                 ws.close();
+//                 await connections.deleteConnection(ws);
+//                 return null;
+//             } catch (e) {
+//                 const errorMsg = (e as Error).message.toLowerCase();
+//                 if (!errorMsg.includes("closed")) {
+//                     return {
+//                         error: {
+//                             message: (e as Error).message
+//                         }
+//                     };
+//                 } else {
+//                     await connections.deleteConnection(ws);
+//                     return null;
+//                 }
+//             }
+//         } else {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//     }
+//     static async subscribe(
+//         ws: WebSocket | null,
+//         tokens: string[]
+//     ): Promise<{ error: { message: string } } | null> {
+//         if (ws === null) {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//         return subscribeHelper(ws, tokens);
+//     }
+//     static async unsubscribe(
+//         ws: WebSocket | null,
+//         tokens: string[]
+//     ): Promise<{ error: { message: string } } | null> {
+//         if (ws === null) {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//         return unsubscribeHelper(ws, tokens);
+//     }
+//     static async subscribeOptionGreeks(
+//         ws: WebSocket | null,
+//         tokens: string[]
+//     ): Promise<{ error: { message: string } } | null> {
+//         if (ws === null) {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//         return subscribeOptionGreeksHelper(ws, tokens);
+//     }
+//     static async unsubscribeOptionGreeks(
+//         ws: WebSocket | null,
+//         tokens: string[]
+//     ): Promise<{ error: { message: string } } | null> {
+//         if (ws === null) {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//         return unsubscribeOptionGreeksHelper(ws, tokens);
+//     }
+// }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firstock",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Node js package for using firstock developer apis",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,6 +11,7 @@
     "LICENSE"
   ],
   "scripts": {
+    "test:ws": "ts-node test_websockets.js",
     "build": "tsc",
     "prepublishOnly": "npm run build",
     "test": "echo \"Error: no test specified\" && exit 1"