firstock 1.0.4 → 1.0.5

package/Readme.md

@@ -5,7 +5,7 @@ To communicate with the Firstock Developer API using Nodejs, you can use the off
 Licensed under the MIT License.
 
 
-[Version - 1.0.0](https://www.npmjs.com/package/firstock)
+[Version - 1.0.5](https://www.npmjs.com/package/firstock)
 
 
 ## Documentation
@@ -277,6 +277,149 @@ firstock.timePriceSeries({
 });
 ```
 
+```javascript
+WebSockets
+
+Order Update Feed
+
+const { Firstock, FirstockWebSocket } = require('./websockets');
+
+// Define callback method 
+function orderBookData(data) {
+    console.log(data);
+}
+
+const userId = 'YOUR_USER_ID';
+
+const model = new FirstockWebSocket({
+    order_data: orderBookData
+});
+
+async function main() {
+    const [conn, err] = await Firstock.initializeWebsockets(userId, model);
+    console.log("Error:", err);
+
+    await new Promise(resolve => setTimeout(resolve, 25000));
+
+    // Close WebSocket connection
+    const closeErr = await Firstock.closeWebsocket(conn);
+    console.log("Close Error:", closeErr);
+}
+
+main();
+
+Position Update Feed
+
+const { Firstock, FirstockWebSocket } = require('./websockets');
+
+// Define callback method 
+function positionBookData(data) {
+    console.log(data);
+}
+
+const userId = 'YOUR_USER_ID';
+
+const model = new FirstockWebSocket({
+    position_data: positionBookData
+});
+
+async function main() {
+    const [conn, err] = await Firstock.initializeWebsockets(userId, model);
+    console.log("Error:", err);
+
+    await new Promise(resolve => setTimeout(resolve, 25000));
+
+    // Close WebSocket connection
+    const closeErr = await Firstock.closeWebsocket(conn);
+    console.log("Close Error:", closeErr);
+}
+
+main();
+
+
+Subscribe Feed
+
+const { Firstock, FirstockWebSocket } = require('./websockets');
+
+// Define callback method 
+function subscribeFeedData(data) {
+    console.log(data);
+}
+
+const userId = 'YOUR_USER_ID';
+
+const model = new FirstockWebSocket({
+    subscribe_feed_data: subscribeFeedData,
+    tokens: ["NSE:26000"]
+});
+
+async function main() {
+    const [conn, err] = await Firstock.initializeWebsockets(userId, model);
+    console.log("Error:", err);
+
+    if (conn) {
+        const subscribeErr = await Firstock.subscribe(conn, ["BSE:1"]);
+        console.log("Subscribe Error:", subscribeErr);
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 25000));
+
+    // Unsubscribe
+    const unsubErr = await Firstock.unsubscribe(conn, ["NSE:26000", "BSE:1"]);
+    console.log("Unsubscribe Error:", unsubErr);
+
+    await new Promise(resolve => setTimeout(resolve, 5000));
+
+    // Close WebSocket connection
+    const closeErr = await Firstock.closeWebsocket(conn);
+    console.log("Close Error:", closeErr);
+}
+
+main();
+
+Subscribe Option Greeks Feed
+
+const { Firstock, FirstockWebSocket } = require('./websockets');
+
+// Define callback method 
+function subscribeOptionGreeksData(data) {
+    console.log(data);
+}
+
+const userId = 'YOUR_USER_ID';
+
+const model = new FirstockWebSocket({
+    subscribe_option_greeks_data: subscribeOptionGreeksData,
+    option_greeks_tokens: ["NFO:44297"]
+});
+
+async function main() {
+    const [conn, err] = await Firstock.initializeWebsockets(userId, model);
+    console.log("Error:", err);
+
+    if (conn) {
+        const subscribeErr = await Firstock.subscribeOptionGreeks(conn, ["NFO:44298"]);
+        console.log("Subscribe Error:", subscribeErr);
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 25000));
+
+    // Unsubscribe
+    const unsubErr = await Firstock.unsubscribeOptionGreeks(conn, ["NFO:44297", "NFO:44298"]);
+    console.log("Unsubscribe Error:", unsubErr);
+
+    await new Promise(resolve => setTimeout(resolve, 5000));
+
+    // Close WebSocket connection
+    const closeErr = await Firstock.closeWebsocket(conn);
+    console.log("Close Error:", closeErr);
+}
+
+main();
+
+```
+
+
 Refer to the [Firstock Connect Documentation](https://connect.thefirstock.com/)  for the complete list of supported methods.
 
 

package/dist/test.js

@@ -6,13 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = __importDefault(require("./index"));
 const firstock = new index_1.default();
 let orderNumber = "";
-// const userDetails = {
-//   userId: "NP2997",
-//   password: "Skanda@202",
-//   TOTP: "1997",
-//   vendorCode: "NP2997_API",
-//   apiKey: "65d837ab42a4b0000fbe05f37ee575fb",
-// };
+const userDetails = {
+    userId: "NP2997",
+    password: "Skanda@2025",
+    TOTP: "1997",
+    vendorCode: "NP2997_API",
+    apiKey: "e55eb28e18ee1337fc0b2705f9b82465",
+};
 // const userDetails = {
 //   userId: "",
 //   password: "",
@@ -21,19 +21,16 @@ let orderNumber = "";
 //   apiKey: "",
 // };
 // // Login and user Details start
-// firstock.login(
-//   {
-//     userId: userDetails.userId,
-//     password: userDetails.password,
-//     TOTP: userDetails.TOTP,
-//     vendorCode: userDetails.vendorCode,
-//     apiKey: userDetails.apiKey,
-//   },
-//   (err: Error | null, result: any) => {
-//     console.log("Error: ", err);
-//     console.log("Result: ", result);
-//   }
-// );
+firstock.login({
+    userId: userDetails.userId,
+    password: userDetails.password,
+    TOTP: userDetails.TOTP,
+    vendorCode: userDetails.vendorCode,
+    apiKey: userDetails.apiKey,
+}, (err, result) => {
+    console.log("Error: ", err);
+    console.log("Result: ", result);
+});
 // // Order and report start
 // firstock.placeOrder(
 //   {

package/dist/websockets/websocket_functions.js

@@ -0,0 +1,668 @@
+"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.connections = exports.UpdateType = void 0;
+exports.getUrlAndHeaderData = getUrlAndHeaderData;
+exports.readMessage = readMessage;
+exports.subscribe = subscribe;
+exports.unsubscribe = unsubscribe;
+exports.subscribeOptionGreeks = subscribeOptionGreeks;
+exports.unsubscribeOptionGreeks = unsubscribeOptionGreeks;
+const ws_1 = __importDefault(require("ws"));
+const fs_1 = require("fs");
+// Configure logging
+const logger = {
+    debug: (msg) => console.debug(`${new Date().toISOString()} - ${msg}`),
+    info: (msg) => console.info(`${new Date().toISOString()} - ${msg}`),
+    warning: (msg) => console.warn(`${new Date().toISOString()} - ${msg}`),
+    error: (msg, err) => {
+        console.error(`[ERROR] ${new Date().toISOString()} - ${msg}`);
+        if (err)
+            console.error(err);
+    }
+};
+var UpdateType;
+(function (UpdateType) {
+    UpdateType["ORDER"] = "order";
+    UpdateType["POSITION"] = "position";
+    UpdateType["MARKET_FEED"] = "market_feed";
+    UpdateType["OPTION_GREEKS"] = "option_greeks";
+})(UpdateType || (exports.UpdateType = UpdateType = {}));
+class SafeConn {
+    constructor(ws) {
+        this.lock = false;
+        this.ws = ws;
+    }
+    acquireLock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (this.lock) {
+                yield new Promise(resolve => setTimeout(resolve, 10));
+            }
+            this.lock = true;
+        });
+    }
+    releaseLock() {
+        this.lock = false;
+    }
+}
+class ConnectionManager {
+    constructor() {
+        this.connMap = new Map();
+        this.indexMap = new Map();
+        this.lock = false;
+    }
+    acquireLock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (this.lock) {
+                yield new Promise(resolve => setTimeout(resolve, 10));
+            }
+            this.lock = true;
+        });
+    }
+    releaseLock() {
+        this.lock = false;
+    }
+    countConnections() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.acquireLock();
+            const count = this.connMap.size;
+            this.releaseLock();
+            return count;
+        });
+    }
+    addConnection(ws) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.acquireLock();
+            if (this.indexMap.has(ws)) {
+                logger.info("Connection already exists");
+                this.releaseLock();
+                return this.indexMap.get(ws);
+            }
+            const safe = new SafeConn(ws);
+            this.connMap.set(safe, true);
+            this.indexMap.set(ws, safe);
+            logger.info("Connection added");
+            this.releaseLock();
+            return safe;
+        });
+    }
+    checkIfConnectionExists(ws) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.acquireLock();
+            const exists = this.indexMap.has(ws);
+            this.releaseLock();
+            return exists;
+        });
+    }
+    writeMessage(ws, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.acquireLock();
+            const safe = this.indexMap.get(ws);
+            this.releaseLock();
+            if (!safe) {
+                return "connection not found";
+            }
+            yield safe.acquireLock();
+            try {
+                if (safe.ws.readyState === ws_1.default.OPEN) {
+                    safe.ws.send(data);
+                    safe.releaseLock();
+                    return null;
+                }
+                else {
+                    safe.releaseLock();
+                    return "WebSocket is not open";
+                }
+            }
+            catch (e) {
+                safe.releaseLock();
+                return e.message;
+            }
+        });
+    }
+    deleteConnection(ws) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.acquireLock();
+            if (this.indexMap.has(ws)) {
+                // Set shutdown flag BEFORE closing
+                _setShutdownFlag(ws);
+                const safe = this.indexMap.get(ws);
+                this.connMap.delete(safe);
+                this.indexMap.delete(ws);
+                try {
+                    if (ws.readyState === ws_1.default.OPEN || ws.readyState === ws_1.default.CONNECTING) {
+                        ws.close();
+                    }
+                }
+                catch (e) {
+                    // Ignore errors during close
+                }
+                logger.info("Connection deleted");
+                // Clear subscription tracking
+                _clearTrackedSubscriptions(ws);
+                this.releaseLock();
+                return;
+            }
+            logger.info("Connection not found");
+            this.releaseLock();
+        });
+    }
+}
+exports.connections = new ConnectionManager();
+const subscriptionTracker = new Map();
+function _getWsId(ws) {
+    return ws.__wsId || (ws.__wsId = Math.random());
+}
+function _trackSubscription(ws, tokens, subscriptionType) {
+    const wsId = _getWsId(ws);
+    if (!subscriptionTracker.has(wsId)) {
+        subscriptionTracker.set(wsId, {
+            tokens: [],
+            option_greeks_tokens: []
+        });
+    }
+    const tracker = subscriptionTracker.get(wsId);
+    for (const token of tokens) {
+        if (!tracker[subscriptionType].includes(token)) {
+            tracker[subscriptionType].push(token);
+        }
+    }
+    logger.debug(`Tracked subscription: ${subscriptionType} - ${tokens.join(', ')}`);
+}
+function _untrackSubscription(ws, tokens, subscriptionType) {
+    const wsId = _getWsId(ws);
+    if (subscriptionTracker.has(wsId)) {
+        const tracker = subscriptionTracker.get(wsId);
+        for (const token of tokens) {
+            const index = tracker[subscriptionType].indexOf(token);
+            if (index > -1) {
+                tracker[subscriptionType].splice(index, 1);
+            }
+        }
+    }
+    logger.debug(`Untracked subscription: ${subscriptionType} - ${tokens.join(', ')}`);
+}
+function _getTrackedSubscriptions(ws) {
+    const wsId = _getWsId(ws);
+    return subscriptionTracker.get(wsId) || { tokens: [], option_greeks_tokens: [] };
+}
+function _clearTrackedSubscriptions(ws) {
+    const wsId = _getWsId(ws);
+    if (subscriptionTracker.has(wsId)) {
+        subscriptionTracker.delete(wsId);
+        logger.debug(`Cleared subscription tracking for connection ${wsId}`);
+    }
+}
+// Shutdown flags
+const shutdownFlags = new Map();
+function _setShutdownFlag(ws) {
+    const wsId = _getWsId(ws);
+    shutdownFlags.set(wsId, true);
+    logger.debug(`Shutdown flag set for connection ${wsId}`);
+}
+function _isShutdownRequested(ws) {
+    const wsId = _getWsId(ws);
+    return shutdownFlags.get(wsId) || false;
+}
+function _clearShutdownFlag(ws) {
+    const wsId = _getWsId(ws);
+    if (shutdownFlags.has(wsId)) {
+        shutdownFlags.delete(wsId);
+        logger.debug(`Shutdown flag cleared for connection ${wsId}`);
+    }
+}
+function getUrlAndHeaderData(userId, config) {
+    const scheme = config.scheme || 'wss';
+    const host = config.host || 'socket.firstock.in';
+    const path = config.path || '/ws';
+    const srcVal = config.source || 'API';
+    const acceptEncoding = config.accept_encoding || 'gzip, deflate, br';
+    const acceptLanguage = config.accept_language || 'en-US,en;q=0.9';
+    const origin = config.origin || '';
+    const baseUrl = `${scheme}://${host}${path}`;
+    logger.info(`Connecting to ${baseUrl}`);
+    let configJson;
+    try {
+        const configFile = (0, fs_1.readFileSync)('config.json', 'utf-8');
+        configJson = JSON.parse(configFile);
+    }
+    catch (e) {
+        return ['', null, new Error('Failed to read config.json')];
+    }
+    // Use the userId parameter to get the jKey
+    if (!configJson[userId]) {
+        return ['', null, new Error(`User ID '${userId}' not found in config.json`)];
+    }
+    const jkey = configJson[userId].jKey;
+    if (!jkey) {
+        return ['', null, new Error(`jKey not found for user '${userId}' in config.json`)];
+    }
+    const queryParams = new URLSearchParams({
+        userId: userId,
+        jKey: jkey,
+        source: 'developer-api'
+    });
+    const urlWithParams = `${baseUrl}?${queryParams.toString()}`;
+    const headers = {
+        'accept-encoding': acceptEncoding,
+        'accept-language': acceptLanguage,
+        'cache-control': 'no-cache',
+        'origin': origin,
+        'pragma': 'no-cache'
+    };
+    return [urlWithParams, headers, null];
+}
+function _identifyUpdateType(data) {
+    if (data.norenordno) {
+        return UpdateType.ORDER;
+    }
+    else if (data.brkname) {
+        return UpdateType.POSITION;
+    }
+    else if (data.gamma) {
+        return UpdateType.OPTION_GREEKS;
+    }
+    else {
+        return UpdateType.MARKET_FEED;
+    }
+}
+function _handleAuthenticationResponse(message) {
+    if (message.includes("Authentication successful")) {
+        logger.info("Authentication successful");
+        return true;
+    }
+    else if (message.includes('"status":"failed"')) {
+        logger.warning(`Authentication failed: ${message}`);
+        return false;
+    }
+    return true;
+}
+function readMessage(userId, ws, model, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const maxRetries = config.max_websocket_connection_retries || 3;
+        const timeInterval = config.time_interval || 5;
+        let messageCount = 0;
+        let isAuthenticated = true;
+        logger.info(`Starting message reader for user ${userId}`);
+        logger.info(`Callbacks configured - Feed: ${model.subscribe_feed_data !== undefined}, ` +
+            `Order: ${model.order_data !== undefined}, ` +
+            `Position: ${model.position_data !== undefined}, ` +
+            `Option Greeks: ${model.subscribe_option_greeks_data !== undefined}`);
+        const messageHandler = (data) => __awaiter(this, void 0, void 0, function* () {
+            if (!(yield exports.connections.checkIfConnectionExists(ws))) {
+                logger.info("Connection no longer exists, stopping reader");
+                _clearShutdownFlag(ws);
+                return;
+            }
+            try {
+                const message = data.toString();
+                messageCount++;
+                logger.debug(`Message #${messageCount}: ${message.substring(0, 200)}...`);
+                if (!message) {
+                    logger.debug("Empty message received, skipping");
+                    return;
+                }
+                let parsedData;
+                try {
+                    parsedData = JSON.parse(message);
+                }
+                catch (e) {
+                    logger.error(`JSON parse error: ${e.message}. Message: ${message.substring(0, 200)}`);
+                    return;
+                }
+                // Handle authentication responses
+                if (parsedData.status && parsedData.message) {
+                    if (_handleAuthenticationResponse(message)) {
+                        isAuthenticated = true;
+                        logger.info("Re-authentication successful");
+                    }
+                    return;
+                }
+                // Route messages to appropriate callbacks
+                const updateType = _identifyUpdateType(parsedData);
+                if (updateType === UpdateType.ORDER) {
+                    if (model.order_data) {
+                        try {
+                            model.order_data(parsedData);
+                            logger.debug("Order callback invoked");
+                        }
+                        catch (e) {
+                            logger.error(`Error in order callback: ${e.message}`, e);
+                        }
+                    }
+                }
+                else if (updateType === UpdateType.POSITION) {
+                    if (model.position_data) {
+                        try {
+                            model.position_data(parsedData);
+                            logger.debug("Position callback invoked");
+                        }
+                        catch (e) {
+                            logger.error(`Error in position callback: ${e.message}`, e);
+                        }
+                    }
+                }
+                else if (updateType === UpdateType.OPTION_GREEKS) {
+                    if (model.subscribe_option_greeks_data) {
+                        try {
+                            if (typeof parsedData === 'object') {
+                                for (const [key, value] of Object.entries(parsedData)) {
+                                    if (typeof value === 'object' && value.gamma) {
+                                        model.subscribe_option_greeks_data(value);
+                                    }
+                                }
+                            }
+                            logger.debug("Option Greeks callback invoked");
+                        }
+                        catch (e) {
+                            logger.error(`Error in option Greeks callback: ${e.message}`, e);
+                        }
+                    }
+                }
+                else {
+                    if (model.subscribe_feed_data) {
+                        try {
+                            model.subscribe_feed_data(parsedData);
+                            logger.debug("Feed callback invoked");
+                        }
+                        catch (e) {
+                            logger.error(`Error in feed callback: ${e.message}`, e);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                logger.error(`Error processing message: ${e.message}`, e);
+            }
+        });
+        const closeHandler = () => __awaiter(this, void 0, void 0, function* () {
+            // Check if shutdown was requested
+            if (_isShutdownRequested(ws)) {
+                logger.info("Connection closed intentionally");
+                _clearShutdownFlag(ws);
+                return;
+            }
+            // Unexpected disconnection - attempt reconnection
+            logger.warning("Unexpected disconnection");
+            console.log("\n Connection lost");
+            console.log("Attempting to reconnect...");
+            if (!(yield exports.connections.checkIfConnectionExists(ws))) {
+                logger.info("Connection no longer in manager, stopping reader");
+                return;
+            }
+            // Attempt reconnection
+            const newWs = yield _attemptReconnection(userId, ws, config, maxRetries, timeInterval, model);
+            if (newWs === null) {
+                logger.error("Failed to reconnect after all attempts");
+                console.log("✗ Failed to reconnect. Please restart the application.");
+                return;
+            }
+            logger.info("Reconnection successful, resuming message reading");
+            // Call user's reconnection callback if provided
+            if (model.on_reconnect) {
+                try {
+                    model.on_reconnect(newWs);
+                    logger.info("User's on_reconnect callback executed");
+                }
+                catch (callbackError) {
+                    logger.error(`Error in on_reconnect callback: ${callbackError.message}`, callbackError);
+                }
+            }
+        });
+        const errorHandler = (error) => __awaiter(this, void 0, void 0, function* () {
+            logger.error(`WebSocket error: ${error.message}`, error);
+            // Trigger close handler for reconnection logic
+            yield closeHandler();
+        });
+        ws.on('message', messageHandler);
+        ws.on('close', closeHandler);
+        ws.on('error', errorHandler);
+    });
+}
+function _attemptReconnection(userId, oldWs, config, maxRetries, timeInterval, model) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Get the actual tracked subscriptions
+        const tracked = _getTrackedSubscriptions(oldWs);
+        const allTokens = tracked.tokens;
+        const allOptionGreeksTokens = tracked.option_greeks_tokens;
+        logger.info(`Attempting reconnection. Will restore: ${allTokens.length} market tokens, ${allOptionGreeksTokens.length} option greeks tokens`);
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            if (!(yield exports.connections.checkIfConnectionExists(oldWs))) {
+                logger.info("Connection no longer exists in manager, stopping reconnection");
+                return null;
+            }
+            logger.info(`Reconnection attempt ${attempt}/${maxRetries}...`);
+            console.log(`Reconnection attempt ${attempt}/${maxRetries}...`);
+            yield new Promise(resolve => setTimeout(resolve, timeInterval * 1000));
+            try {
+                // Create new connection
+                const [baseUrl, headers, err] = getUrlAndHeaderData(userId, config);
+                if (err) {
+                    logger.error(`Failed to get URL/headers: ${err.message}`);
+                    continue;
+                }
+                const newWs = new ws_1.default(baseUrl, { headers });
+                // Wait for connection to open
+                yield new Promise((resolve, reject) => {
+                    const timeout = setTimeout(() => {
+                        reject(new Error('Connection timeout'));
+                    }, 10000);
+                    newWs.once('open', () => {
+                        clearTimeout(timeout);
+                        resolve();
+                    });
+                    newWs.once('error', (error) => {
+                        clearTimeout(timeout);
+                        reject(error);
+                    });
+                });
+                logger.info(`New WebSocket connection created (attempt ${attempt})`);
+                // Wait for authentication message
+                const authMessage = yield new Promise((resolve, reject) => {
+                    const timeout = setTimeout(() => {
+                        reject(new Error('Authentication timeout'));
+                    }, 5000);
+                    newWs.once('message', (data) => {
+                        clearTimeout(timeout);
+                        resolve(data.toString());
+                    });
+                    newWs.once('error', (error) => {
+                        clearTimeout(timeout);
+                        reject(error);
+                    });
+                });
+                logger.info(`Reconnection auth message: ${authMessage}`);
+                if (!authMessage.includes("Authentication successful")) {
+                    logger.warning(`Authentication failed on reconnect: ${authMessage}`);
+                    newWs.close();
+                    continue;
+                }
+                // Transfer subscription tracking from old connection to new connection
+                const oldWsId = _getWsId(oldWs);
+                const newWsId = _getWsId(newWs);
+                if (subscriptionTracker.has(oldWsId)) {
+                    const oldTracker = subscriptionTracker.get(oldWsId);
+                    subscriptionTracker.set(newWsId, {
+                        tokens: [...oldTracker.tokens],
+                        option_greeks_tokens: [...oldTracker.option_greeks_tokens]
+                    });
+                    logger.debug(`Transferred subscription tracking from ${oldWsId} to ${newWsId}`);
+                }
+                // Update connection manager
+                yield exports.connections.deleteConnection(oldWs);
+                yield exports.connections.addConnection(newWs);
+                logger.info("Connection manager updated with new connection");
+                // Resubscribe to all tracked tokens
+                logger.info("Resubscribing to previous subscriptions...");
+                console.log("Resubscribing to previous feeds...");
+                // Resubscribe to market feed tokens
+                if (allTokens.length > 0) {
+                    yield new Promise(resolve => setTimeout(resolve, 500));
+                    const tokensStr = allTokens.join("|");
+                    const msg = JSON.stringify({ action: "subscribe", tokens: tokensStr });
+                    const error = yield exports.connections.writeMessage(newWs, msg);
+                    if (error) {
+                        logger.error(`Failed to resubscribe to market tokens: ${error}`);
+                    }
+                    else {
+                        logger.info(`Resubscribed to ${allTokens.length} market feed token(s): ${allTokens.join(', ')}`);
+                        console.log(`✓ Resubscribed to ${allTokens.length} market feed token(s)`);
+                    }
+                }
+                if (allOptionGreeksTokens.length > 0) {
+                    yield new Promise(resolve => setTimeout(resolve, 500));
+                    const tokensStr = allOptionGreeksTokens.join("|");
+                    const msg = JSON.stringify({ action: "subscribe-option-greeks", tokens: tokensStr });
+                    const error = yield exports.connections.writeMessage(newWs, msg);
+                    if (error) {
+                        logger.error(`Failed to resubscribe to option Greeks: ${error}`);
+                    }
+                    else {
+                        logger.info(`Resubscribed to ${allOptionGreeksTokens.length} option Greeks token(s): ${allOptionGreeksTokens.join(', ')}`);
+                        console.log(`✓ Resubscribed to ${allOptionGreeksTokens.length} option Greeks token(s)`);
+                    }
+                }
+                yield new Promise(resolve => setTimeout(resolve, 1000));
+                logger.info("Reconnection and resubscription successful!");
+                console.log("✓ Reconnection complete - all subscriptions restored");
+                // IMPORTANT: Restart the message reader for the new WebSocket
+                readMessage(userId, newWs, model, config);
+                return newWs;
+            }
+            catch (e) {
+                logger.error(`Reconnection attempt ${attempt} failed: ${e.message}`, e);
+                console.log(`✗ Attempt ${attempt} failed: ${e.message.substring(0, 100)}...`);
+                if (attempt === maxRetries) {
+                    logger.error("Max reconnection attempts reached");
+                    console.log(`✗ All ${maxRetries} reconnection attempts failed`);
+                    return null;
+                }
+            }
+        }
+        return null;
+    });
+}
+function subscribe(ws, tokens) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield exports.connections.checkIfConnectionExists(ws))) {
+            return {
+                error: {
+                    message: "Connection does not exist"
+                }
+            };
+        }
+        _trackSubscription(ws, tokens, 'tokens');
+        let tokensStr;
+        if (tokens.length === 1 && tokens[0].includes("|")) {
+            tokensStr = tokens[0];
+        }
+        else {
+            tokensStr = tokens.join("|");
+        }
+        const msg = JSON.stringify({
+            action: "subscribe",
+            tokens: tokensStr
+        });
+        logger.info(`Sending subscribe message: ${msg}`);
+        const error = yield exports.connections.writeMessage(ws, msg);
+        if (error) {
+            return { error: { message: error } };
+        }
+        logger.info("Subscribe message sent successfully");
+        return null;
+    });
+}
+function unsubscribe(ws, tokens) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield exports.connections.checkIfConnectionExists(ws))) {
+            return {
+                error: {
+                    message: "Connection does not exist"
+                }
+            };
+        }
+        _untrackSubscription(ws, tokens, 'tokens');
+        const tokensStr = tokens.join("|");
+        const msg = JSON.stringify({
+            action: "unsubscribe",
+            tokens: tokensStr
+        });
+        logger.info(`Sending unsubscribe message: ${msg}`);
+        const error = yield exports.connections.writeMessage(ws, msg);
+        if (error) {
+            return { error: { message: error } };
+        }
+        return null;
+    });
+}
+function subscribeOptionGreeks(ws, tokens) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield exports.connections.checkIfConnectionExists(ws))) {
+            return {
+                error: {
+                    message: "Connection does not exist"
+                }
+            };
+        }
+        _trackSubscription(ws, tokens, 'option_greeks_tokens');
+        let tokensStr;
+        if (tokens.length === 1 && tokens[0].includes("|")) {
+            tokensStr = tokens[0];
+        }
+        else {
+            tokensStr = tokens.join("|");
+        }
+        const msg = JSON.stringify({
+            action: "subscribe-option-greeks",
+            tokens: tokensStr
+        });
+        logger.info(`Sending subscribe option greeks message: ${msg}`);
+        const error = yield exports.connections.writeMessage(ws, msg);
+        if (error) {
+            return { error: { message: error } };
+        }
+        logger.info("Subscribe option greeks message sent successfully");
+        return null;
+    });
+}
+function unsubscribeOptionGreeks(ws, tokens) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield exports.connections.checkIfConnectionExists(ws))) {
+            return {
+                error: {
+                    message: "Connection does not exist"
+                }
+            };
+        }
+        _untrackSubscription(ws, tokens, 'option_greeks_tokens');
+        let tokensStr;
+        if (tokens.length === 1 && tokens[0].includes("|")) {
+            tokensStr = tokens[0];
+        }
+        else {
+            tokensStr = tokens.join("|");
+        }
+        const msg = JSON.stringify({
+            action: "unsubscribe-option-greeks",
+            tokens: tokensStr
+        });
+        logger.info(`Sending unsubscribe option greeks message: ${msg}`);
+        const error = yield exports.connections.writeMessage(ws, msg);
+        if (error) {
+            return { error: { message: error } };
+        }
+        logger.info("Unsubscribe option greeks message sent successfully");
+        return null;
+    });
+}

package/dist/websockets/websockets.js

@@ -0,0 +1,213 @@
+"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");
+const logger = {
+    info: (msg) => console.info(`[INFO] ${new Date().toISOString()} - ${msg}`),
+    error: (msg, err) => {
+        console.error(`[ERROR] ${new Date().toISOString()} - ${msg}`);
+        if (err)
+            console.error(err);
+    }
+};
+class FirstockWebSocket {
+    constructor(options = {}) {
+        this.tokens = options.tokens || [];
+        this.option_greeks_tokens = options.option_greeks_tokens || [];
+        this.order_data = options.order_data;
+        this.position_data = options.position_data;
+        this.subscribe_feed_data = options.subscribe_feed_data;
+        this.subscribe_option_greeks_data = options.subscribe_option_greeks_data;
+        this.on_reconnect = options.on_reconnect;
+    }
+    toDict() {
+        return {
+            tokens: this.tokens,
+            option_greeks_tokens: this.option_greeks_tokens,
+            order_data: this.order_data,
+            position_data: this.position_data,
+            subscribe_feed_data: this.subscribe_feed_data,
+            subscribe_option_greeks_data: this.subscribe_option_greeks_data,
+            on_reconnect: this.on_reconnect
+        };
+    }
+}
+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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firstock",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Node js package for using firstock developer apis",
   "main": "dist/index.js",
   "type": "commonjs",
@@ -23,10 +23,13 @@
   "homepage": "https://github.com/the-firstock/firstock-developer-sdk-nodejs#readme",
   "dependencies": {
     "axios": "^1.10.0",
-    "sha256": "^0.2.0"
+    "sha256": "^0.2.0",
+    "util": "^0.12.5",
+    "ws": "^8.18.3"
   },
   "devDependencies": {
     "@types/sha256": "^0.2.2",
+    "@types/ws": "^8.18.1",
     "typescript": "^5.8.3"
   }
 }

package/websockets/test_websockets.js

@@ -0,0 +1,187 @@
+const { Firstock, FirstockWebSocket } = require('./websockets');
+const { appendFileSync } = require('fs');
+
+function subscribeFeedData(data) {
+    try {
+        appendFileSync('websocket.log', `${JSON.stringify(data)}\n`);
+        console.log(data);
+    } catch (e) {
+        console.error(`Error writing to log: ${e}`);
+    }
+}
+
+function subscribeOptionGreeksData(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('option_greeks.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error writing option Greeks: ${e}`);
+    }
+}
+
+function orderBookData(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('order_detail.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error opening log file: ${e}`);
+    }
+}
+
+function positionBookData(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('position_detail.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error opening log file: ${e}`);
+    }
+}
+
+function subscribeFeedData2(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('websocket2.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error opening log file: ${e}`);
+    }
+}
+
+function subscribeFeedData3(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('websocket3.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error opening log file: ${e}`);
+    }
+}
+
+function subscribeFeedData4(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('websocket4.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error opening log file: ${e}`);
+    }
+}
+
+async function main() {
+    const userId = 'NP2997';
+
+    // Connection reference holder
+    const connectionRef = { conn: null };
+
+    // Reconnection callback
+    function onReconnectCallback(newWs) {
+        console.log("🔄 Connection reference updated");
+        connectionRef.conn = newWs;
+    }
+
+    // Create WebSocket model
+    const model = new FirstockWebSocket({
+        tokens: [],
+        option_greeks_tokens: [],
+        order_data: orderBookData,
+        position_data: positionBookData,
+        subscribe_feed_data: subscribeFeedData,
+        subscribe_option_greeks_data: subscribeOptionGreeksData,
+        on_reconnect: onReconnectCallback
+    });
+
+    // Initialize WebSocket
+    const [conn, err] = await Firstock.initializeWebsockets(userId, model);
+    connectionRef.conn = conn;
+    
+    console.log("Error:", err);
+
+    if (err) {
+        console.log(`Connection failed: ${JSON.stringify(err)}`);
+        return;
+    } else {
+        console.log("WebSocket connected successfully!");
+    }
+
+    // Subscribe to tokens
+    const subscribeErr = await Firstock.subscribe(connectionRef.conn, ["BSE:500470|NSE:26000"]);
+    console.log("Subscribe Error:", subscribeErr);
+
+    // Subscribe to option Greeks (uncomment to use)
+    // const optionErr = await Firstock.subscribeOptionGreeks(connectionRef.conn, ["NFO:44297"]);
+    // console.log("Option Greeks Subscribe Error:", optionErr);
+
+    // // Later, unsubscribe (uncomment to use)
+    // await new Promise(resolve => setTimeout(resolve, 30000));
+    // const unsubErr = await Firstock.unsubscribeOptionGreeks(connectionRef.conn, ["NFO:44283"]);
+    // console.log("Option Greeks Unsubscribe Error:", unsubErr);
+
+    // Multiple connections example (uncomment to use)
+    
+    // const model2 = new FirstockWebSocket({
+    //     tokens: [],
+    //     subscribe_feed_data: subscribeFeedData2
+    // });
+    // const [conn2, err2] = await Firstock.initializeWebsockets(userId, model2);
+    // console.log("Error:", err2);
+    
+    // const subscribeErr2 = await Firstock.subscribe(conn2, ["BSE:1"]);
+    // console.log("Error:", subscribeErr2);
+
+    // const model3 = new FirstockWebSocket({
+    //     tokens: [],
+    //     subscribe_feed_data: subscribeFeedData3
+    // });
+    // const [conn3, err3] = await Firstock.initializeWebsockets(userId, model3);
+    // console.log("Error:", err3);
+    
+    // const subscribeErr3 = await Firstock.subscribe(conn3, ["NSE:26000|BSE:1"]);
+    // console.log("Error:", subscribeErr3);
+
+    // const model4 = new FirstockWebSocket({
+    //     tokens: [],
+    //     subscribe_feed_data: subscribeFeedData4
+    // });
+    // const [conn4, err4] = await Firstock.initializeWebsockets(userId, model4);
+    // console.log("Error:", err4);
+    
+    // const subscribeErr4 = await Firstock.subscribe(conn4, ["NSE:26000"]);
+    // console.log("Error:", subscribeErr4);
+    
+    // Unsubscribe example
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    const unsubErr = await Firstock.unsubscribe(connectionRef.conn, ["BSE:500470|NSE:26000"]);
+    console.log("Unsubscribe Error:", unsubErr);
+
+    // Wait for 25 seconds
+    await new Promise(resolve => setTimeout(resolve, 200000));
+
+    // Close WebSocket connection
+    const closeErr = await Firstock.closeWebsocket(connectionRef.conn);
+    console.log("Close Error:", closeErr);
+
+    // Close additional connections (uncomment if using multiple connections)
+    // const closeErr2 = await Firstock.closeWebsocket(conn2);
+    // console.log("Close Error:", closeErr2);
+    
+    // const closeErr3 = await Firstock.closeWebsocket(conn3);
+    // console.log("Close Error:", closeErr3);
+
+    // Keep program running
+    console.log("\nWebSocket test running. Press Ctrl+C to exit.");
+    
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+        console.log("\nExiting...");
+        if (connectionRef.conn) {
+            await Firstock.closeWebsocket(connectionRef.conn);
+        }
+        process.exit(0);
+    });
+
+    // Keep alive - never resolves, keeps running until SIGINT
+    await new Promise(() => {});
+}
+
+// Run main function
+main().catch(error => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});