fyers-web-sdk-v3 1.0.0

package/config/config.js

@@ -0,0 +1,26 @@
+export const Config = {
+    "API":"https://api.fyers.in/api/v2",
+    "SYNC_API":"https://api-t1.fyers.in/api/v3",
+    "data_Api": "https://api.fyers.in/data-rest/v2",
+    "data_Api1": "https://api-t1.fyers.in/data",
+    "HSM_SOCKET": "wss://socket.fyers.in/hsm/v1-5/prod",
+    "Order_SOCKET": "wss://socket.fyers.in/trade/v3",
+    "get_profile" : "/profile",
+    "tradebook" : "/tradebook",
+    "positions" : "/positions",
+    "holdings" : "/holdings",
+    "convertPosition" : "/positions",
+    "funds" : "/funds",
+    "gtt":"/gtt",
+    "orders" : "/orders",
+    "orders_sync" : "/orders/sync",
+    "orderStatus" : "/order-status",
+    "marketStatus" : "/marketStatus",
+    "auth" : "/generate-authcode",
+    "generateAccessToken" : "/validate-authcode",
+    "exitPositions" : "/positions",
+    "multi_orders" : "/multi-order/sync",
+    "history" : "/history",
+    "quotes" : "/quotes",
+    "market_depth" : "/depth"
+}

package/errorHandler/errorHandler.js

@@ -0,0 +1,37 @@
+export class ErrorHandler {
+    #genricErrorStructure = {s: 'error', code: 500, message: 'Genric Error'}
+
+
+    constructor(errorObject) {
+        this.errorObject = errorObject
+    }
+
+    getError() {
+        if (this.errorObject && this.errorObject.response && this.errorObject.response.data) {
+            return this.errorObject.response.data;
+        } else if (this.errorObject && (this.errorObject.code === 'ENOTFOUND')) {
+            return this.setError(this.errorObject.errno, this.errorObject.code)
+        }else if(this.errorObject.code){
+            return this.setError(null, this.errorObject.code)
+        } else if(this.errorObject){
+            return this.setError(null, this.errorObject)
+        } {
+            return this.#genricErrorStructure
+        }
+    }
+
+
+    setError(code, message) {
+        if(code){
+            this.#genricErrorStructure.code = code
+        }
+        if(message){
+            this.#genricErrorStructure.message = message
+        }
+
+        return this.#genricErrorStructure
+    }
+
+}
+
+// module.exports = ErrorHandler;

package/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { FyersApi } from "./apiService/apiService.js"
+import {FyersOrderSocket} from "./ordersocket/fyersSocket.js"
+import {DataSocket} from"./HSM/datasocket.min.js"
+
+export {FyersApi as fyersModel, DataSocket as fyersDataSocket, FyersOrderSocket as fyersOrderSocket}

package/logger/log.js

@@ -0,0 +1,62 @@
+const fs = require('fs');
+const path = require('path');
+
+class Logger {
+  constructor(logDirectory = process.cwd(),logflag=true) {
+    const currentDate = new Date().toISOString().slice(0, 10);
+    this.logFileName =  `${currentDate}.log`;
+    this.logFilePath = path.join(logDirectory, this.logFileName);
+    this.logflag=logflag
+  }
+
+  log(level, message, data, functionName) {
+    if (!this.logflag){
+      return
+    }
+    const logEntry = {
+      level,
+      datetime: new Date().toISOString(),
+      message,
+      data,
+      functionName,
+    };
+
+    const logString = JSON.stringify(logEntry) + '\n';
+
+    fs.appendFile(this.logFilePath, logString, (err) => {
+      if (err) {
+        console.error('Failed to write to log file:', err);
+      }
+    });
+  }
+
+  debug(message, data, functionName) {
+    this.log('debug', message, data, functionName);
+  }
+
+  info(message, data, functionName) {
+    this.log('info', message, data, functionName);
+  }
+
+  warn(message, data, functionName) {
+    this.log('warn', message, data, functionName);
+  }
+
+  error(message, data, functionName) {
+    this.log('error', message, data, functionName);
+  }
+}
+
+// Usage example
+// const logger = new Logger(undefined); // Log file will be created in the current working directory with the name "YYYY-MM-DD.log"
+// logger.debug('Debug message', { example: 'data' }, 'myFunction');
+// logger.info('Info message', null, 'myFunction');
+// logger.warn('Warning message', { example: 'data' }, 'myFunction');
+// logger.error('Error message', { example: 'data' }, 'myFunction');
+
+// const customLogDirectory = '/home/nihar/fyers_project/node SDK/logger';
+// const customLogger = new Logger(customLogDirectory);
+// customLogger.debug('Custom debug message', null, 'myFunction');
+// customLogger.info('Custom info message', { example: 'data' }, 'myFunction');
+
+module.exports = Logger

package/obfuscate.js

@@ -0,0 +1,25 @@
+const fs = require('fs');
+const JavaScriptObfuscator = require('javascript-obfuscator');
+
+const inputFilePath = './HSM/datasocket.js';
+const outputFilePath = './HSM/datasocket.min.js';
+
+const inputFileContent = fs.readFileSync(inputFilePath, 'utf8');
+
+const obfuscationResult = JavaScriptObfuscator.obfuscate(inputFileContent, {
+    compact: true,
+    controlFlowFlattening: true,
+    controlFlowFlatteningThreshold: 1,
+    numbersToExpressions: true,
+    simplify: true,
+    shuffleStringArray: true,
+    splitStrings: true,
+    splitStringsChunkLength: 10,
+    stringArray: true,
+    stringArrayThreshold: 1,
+    transformObjectKeys: true, 
+});
+
+fs.writeFileSync(outputFilePath, obfuscationResult.getObfuscatedCode(), 'utf8');
+
+console.log('Obfuscation completed.');

package/ordersocket/fyersSocket.js

@@ -0,0 +1,325 @@
+import {Config} from "../config/config.js";
+import {mapper} from "./mapper.js"
+var reconnectiontries = 0
+const ordstatobj={11: 4, 12: 4, 20: 4, 21: 4, 22: 6, 23: 6, 24: 6, 25: 6, 26: 6, 90: 2,
+    91: 1, 92: 5, 93: 5, 94: 5, 51: 6, 52: 6, 53: 6, 54: 6, 55: 6, 61: 6, 62: 6, 63: 6,
+    64: 6, 71: 6, 72: 6, 73: 1}
+function datamapper(a,b){
+    const result = {};
+
+    for (const key of Object.keys(b)) {
+      if (a.hasOwnProperty(key)) {
+        result[b[key]] = a[key];
+      }
+    }
+  
+    return result;
+}
+/**
+ * Class to access order update websocket.
+ * @class
+ */
+class FyersOrderSocket {
+
+    constructor(authorizationKey, logpath = undefined ,loggingFlag=true) {
+        this.url = Config.Order_SOCKET;
+        this.authorizationKey = authorizationKey;
+        this.ws = null;
+        this.onErrorCallback = null;
+        this.onCloseCallback = null;
+        this.onMessageCallback = null;
+        this.onOpenCallback = null;
+        this.orderscallback = null;
+        this.LogPath = logpath;
+        // this.Logger = new Logger(this.LogPath,loggingFlag);
+        this.positionscallback = null;
+        this.tradescallback = null;
+        this.isPingEnabled = true;
+        this.pingInterval = null;
+        this.autoreconnectinterval = null;
+        this.orderUpdates = "orders"
+        this.tradeUpdates = "trades"
+        this.positionUpdates = "positions"
+        this.edis="edis"
+        this.pricealerts="pricealerts"
+        this.isUserClosed=false
+        this.autoreconnectflag=false
+        this.maxreconnectiontries = 0
+    }
+
+    /**
+     * called to connect to the order socket
+     */
+    connect() {
+        const funcname = "connect"
+        // const logger = this.Logger
+        try {
+            // console.debug("initalizing connection to socket", { "accesstoken": this.authorizationKey }, funcname)
+            // this.ws = new WebSocket(this.url);
+            // var temp=Buffer.from(this.authorizationKey).toString('base64')
+            var temp = btoa(this.authorizationKey);
+            temp=encodeURIComponent(temp)
+            this.ws = new WebSocket(this.url, [temp]);
+
+            console.log(this.url)
+            this.ws.binaryType = 'arraybuffer';
+            this.ws.addEventListener('error', (error) => {
+                if (this.onErrorCallback) {
+                    this.onErrorCallback(error);
+                }
+                else {
+                    console.log("error occoured", error)
+                }
+            });
+
+            this.ws.addEventListener('close', (event) => {
+                this.stopPing()
+                if (this.onCloseCallback) {
+                    this.onCloseCallback(event);
+                }
+                else {
+                    console.log("ws closed", event)
+                    if(!this.isUserClosed&&(reconnectiontries<this.maxreconnectiontries)){
+                        this._autoreconnect()
+                    }
+                }
+            });
+
+            this.ws.addEventListener('message', (message) => {
+                const data = message.data;
+                if (data === 'pong') {
+                    return
+                }
+                else {
+                    var parseddata = JSON.parse(data)
+                    if (parseddata.hasOwnProperty("orders")) {
+                        var orderdata=datamapper(parseddata["orders"],mapper.orders)
+                        orderdata.status=ordstatobj[orderdata.status]
+                        orderdata['orderNumStatus']=orderdata.id+':'+orderdata.status
+                        if (this.orderscallback) {
+                            this.orderscallback({"s":"ok","orders":orderdata})
+                        }
+                        else {
+                            console.log("Orders_internal", {"s":"ok","orders":orderdata})
+                        }
+                    }
+                    else if (parseddata.hasOwnProperty("positions")) {
+                        var positiondata=datamapper(parseddata["positions"],mapper.position)
+                        if (this.positionscallback) {
+                            this.positionscallback({"s":"ok","positions":positiondata})
+                        }
+                        else {
+                            console.log("positions_internal", {"s":"ok","positions":positiondata})
+                        }
+                    }
+                    else if (parseddata.hasOwnProperty("trades")) {
+                        var tradebookdata=datamapper(parseddata["trades"],mapper.tradebook)
+                        if (this.tradescallback) {
+                            this.tradescallback({"s":"ok","trades":tradebookdata})
+                        }
+                        else {
+                            console.log("trades_internal", {"s":"ok","trades":tradebookdata})
+                        }
+                    }
+                    else {
+                        if (this.onMessageCallback) {
+                            this.onMessageCallback(parseddata);
+                        }
+                        else {
+                            console.log("message_internal", parseddata)
+                        }
+                    }
+
+                }
+            });
+
+            this.ws.addEventListener('open', () => {
+                reconnectiontries = 0
+                if (this.onOpenCallback) {
+                    this.onOpenCallback();
+                }
+                else {
+                    console.log("connected")
+                }
+
+                if (this.isPingEnabled) {
+                    this.startPing();
+                }
+            });
+        }
+        catch (error) {
+            console.log(`Error occured ${funcname}: ${error}`)
+            console.error("unexpected error on connect function", error, funcname)
+        }
+    }
+
+    /**
+     * used to define onmessage,onerror,onopen,onclose for websocket.
+     * @param {string} onwhat - defines for what the callback function is.
+     * @param {Function} callback - the callback function.
+     * @throws  error message if onwhat is not valid.
+     */
+    on(onwhat, callback) {
+        const funcname = "on"
+        // const logger = this.Logger
+        try {
+            if (onwhat === 'error') {
+                this.onErrorCallback = callback;
+            }
+            else if (onwhat === 'general') {
+                this.onMessageCallback = callback;
+            }
+            else if (onwhat === 'connect') {
+                this.onOpenCallback = callback;
+            }
+            else if (onwhat === 'close') {
+                const socketonclose = function (event){
+                    callback(event)
+                    if(!this.isUserClosed&&(reconnectiontries<this.maxreconnectiontries)){
+                        this._autoreconnect()
+                    }
+                }
+                this.onCloseCallback = socketonclose;
+            }
+            else if (onwhat === 'orders') {
+                this.orderscallback = callback;
+            }
+            else if (onwhat === 'trades') {
+                this.tradescallback = callback;
+            }
+            else if (onwhat === 'positions') {
+                this.positionscallback = callback;
+            }
+            else {
+                console.log("incorrect value passed", onwhat)
+                console.error("wrong onwhat passed", { "onwhat": onwhat }, funcname)
+            }
+        }
+        catch (error) {
+            console.error("unexpected error on 'on' function", error, funcname)
+        }
+    }
+
+    /**
+     * call to check if datasocket is connected
+     */
+    isConnected() {
+        return this.ws && this.ws.readyState === WebSocket.OPEN;
+    }
+
+    /**
+     * starts ping messages to ws
+     */
+    startPing() {
+        this.pingInterval = setInterval(() => {
+            if (this.isConnected()) {
+                this.ws.send("ping");
+            }
+        }, 1000);
+    }
+
+    /**
+     * stops pinging mechanism
+     */
+    stopPing() {
+        clearInterval(this.pingInterval);
+    }
+
+    /**
+     * Subscribe to socket.
+     * @param {Array|string} towhat - array or string of what you want to subscribe to.
+     */
+    subscribe(towhat) {
+        const funcname = "subscribe"
+        // const logger = this.Logger
+        try {
+            if (this.isConnected()) {
+                console.debug("trying to subscribe to", { "towhat": towhat }, funcname)
+                if (towhat.constructor === Array) {
+                    this.ws.send(JSON.stringify({ "T": "SUB_ORD", "SLIST": towhat, "SUB_T": 1 }));
+                }
+                else {
+                    this.ws.send(JSON.stringify({ "T": "SUB_ORD", "SLIST": [towhat], "SUB_T": 1 }));
+                }
+            }
+            else {
+                console.error("websocket is not connected", { "towhat": towhat }, funcname)
+                console.log('Cannot send message. WebSocket is not connected.');
+            }
+        }
+        catch (error) {
+
+            console.error("unexpected error on subscribe function", error, funcname)
+        }
+    }
+
+    /**
+     * Unsubscribe to socket.
+     * @param {Array|string} towhat - array or string of what you want to unsubscribe to.
+     */
+    unsubscribe(towhat) {
+        const funcname = "unsubscribe"
+        // const logger = this.Logger
+        try {
+            if (this.isConnected()) {
+                if (towhat.constructor === Array) {
+                    console.debug("trying to unsubscribe to", { "towhat": towhat }, funcname)
+                    this.ws.send(JSON.stringify({ "T": "SUB_ORD", "SLIST": towhat, "SUB_T": -1 }));
+                }
+                else {
+                    this.ws.send(JSON.stringify({ "T": "SUB_ORD", "SLIST": [towhat], "SUB_T": -1 }));
+                }
+            }
+            else {
+                console.error("websocket is not connected", { "towhat": towhat }, funcname)
+                // console.log('Cannot send message. WebSocket is not connected.');
+            }
+        }
+        catch (error) {
+            console.error("unexpected error on unsubscribe function", error, funcname)
+        }
+    }
+
+    /**
+     * call to close the datasocket.
+     */
+    close() {
+        if (this.ws && this.isConnected) {
+            clearInterval(this.autoreconnectinterval)
+            this.stopPing()
+            this.ws.close();
+            this.isUserClosed = true
+        }
+    }
+
+    /**
+     * call to enable autoreconnect functionality of websocket.
+     */
+    _autoreconnect() {
+        if (this.autoreconnectflag){
+            var waitSeconds = Math.floor((reconnectiontries+5)/5);
+            waitSeconds *= 5;
+
+            this.autoreconnectinterval = setTimeout(() => {
+                if ((!this.isConnected()) && (reconnectiontries < this.maxreconnectiontries)) {
+                    console.log("trying to reconnect ", reconnectiontries + 1)
+                    reconnectiontries++
+                    this.connect()
+                } else if (reconnectiontries >= this.maxreconnectiontries) {
+                    console.log("max autoconnect tries exceeded")
+                    clearInterval(this.autoreconnectinterval)
+                    this.stopPing()
+                    reconnectiontries = 0
+                }
+            },  (waitSeconds)*1000);
+        }
+    }
+    /**
+     * call to enable autoreconnect functionality of websocket.
+     */
+    autoreconnect(reConnectTriesCount=5){
+        this.autoreconnectflag=true
+        this.maxreconnectiontries=(reConnectTriesCount>50) ? 50 : reConnectTriesCount
+    }
+}
+export {FyersOrderSocket}

package/ordersocket/mapper.js

@@ -0,0 +1,79 @@
+const ordersMapper = {
+    'client_id': 'clientId',
+    'id': 'id',
+    'id_parent': 'parentId',
+    'id_exchange': 'exchOrdId',
+    'qty': 'qty',
+    'qty_remaining': 'remainingQuantity',
+    'qty_filled': 'filledQty',
+    'price_limit': 'limitPrice',
+    'price_stop': 'stopPrice',
+    'tradedPrice': 'price_traded',
+    'ord_type': 'type',
+    'fy_token': 'fyToken',
+    'exchange': 'exchange',
+    'segment': 'segment',
+    'symbol': 'symbol',
+    'instrument': 'instrument',
+    'oms_msg': 'message',
+    'offline_flag': 'offlineOrder',
+    'time_oms': 'orderDateTime',
+    'validity': 'orderValidity',
+    'product_type': 'productType',
+    'tran_side': 'side',
+    'ord_status': 'status',
+    'ord_source': 'source',
+    'symbol_exch': 'ex_sym',
+    'symbol_desc': 'description',
+    'ordertag': 'orderTag'
+}
+
+const positionbookMapper = {
+    'symbol': 'symbol',
+    'id': 'id',
+    'buy_avg': 'buyAvg',
+    'buy_qty': 'buyQty',
+    'buy_val': 'buyVal',
+    'sell_avg': 'sellAvg',
+    'sell_qty': 'sellQty',
+    'sell_val': 'sellVal',
+    'net_avg': 'netAvg',
+    'net_qty': 'netQty',
+    'tran_side': 'side',
+    'qty': 'qty',
+    'product_type': 'productType',
+    'pl_realized': 'realized_profit',
+    'rbirefrate': 'rbiRefRate',
+    'fy_token': 'fyToken',
+    'exchange': 'exchange',
+    'segment': 'segment',
+    'day_buy_qty': 'dayBuyQty',
+    'day_sell_qty': 'daySellQty',
+    'cf_buy_qty': 'cfBuyQty',
+    'cf_sell_qty': 'cfSellQty',
+    'qty_multiplier': 'qtyMulti_com',
+    'pl_total': 'pl',
+    'cross_curr_flag': 'crossCurrency',
+    'pl_unrealized': 'unrealized_profit',
+}
+
+const tradebookMapper = {
+    'id_fill': 'tradeNumber',
+    'id': 'orderNumber',
+    'qty_traded': 'tradedQty',
+    'price_traded': 'tradePrice',
+    'traded_val': 'tradeValue',
+    'product_type': 'productType',
+    'client_id': 'clientId',
+    'id_exchange': 'exchangeOrderNo',
+    'ord_type': 'orderType',
+    'tran_side': 'side',
+    'symbol': 'symbol',
+    'fill_time': 'orderDateTime',
+    'fy_token': 'fyToken',
+    'exchange': 'exchange',
+    'segment': 'segment',
+    'ordertag': 'orderTag'
+}
+
+export const mapper = { "orders": ordersMapper, "position": positionbookMapper, "tradebook": tradebookMapper }

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "fyers-web-sdk-v3",
+  "version": "1.0.0",
+  "description": "fyers api for web compatibility",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "devDependencies": {
+    "javascript-obfuscator": "^4.0.2"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/sample/api.js

@@ -0,0 +1,46 @@
+var fyersModel= require("../index.js").fyersModel
+
+var fyers= new fyersModel()
+
+fyers.setAppId("QC7T0H8425-100")
+
+fyers.setRedirectUrl("https://www.google.com")
+// generate authcode
+////////////////////////////
+
+// var URL=fyers.generateAuthCode()
+
+// console.log(URL)
+
+// after getting authcode
+
+////////////////////////////
+
+// generate accesstoken
+////////////////////////////
+// var authcode=""
+
+// fyers.generate_access_token({"client_id":fyers.AppID,"secret_key":"4362L6SS2C","auth_code":authcode}).then((response)=>{
+//     console.log(response)
+// })
+////////////////////////////
+
+fyers.setAccessToken("")
+
+fyers.get_profile().then((response)=>{
+        console.log(response)
+    }).catch((err)=>{
+        console.log(err)
+    })
+    
+fyers.getQuotes(["NSE:SBIN-EQ","NSE:TCS-EQ"]).then((response)=>{
+    console.log(response)
+}).catch((err)=>{
+    console.log(err)
+})
+
+fyers.getMarketDepth({"symbol":["NSE:SBIN-EQ","NSE:TCS-EQ"],"ohlcv_flag":1}).then((response)=>{
+    console.log(response)
+}).catch((err)=>{
+    console.log(err)
+})

package/sample/datasocket.js

@@ -0,0 +1,25 @@
+import {DataSocket} from "../index.js"
+
+var skt= DataSocket.getInstance("")
+
+skt.on("connect",function(){skt.subscribe(['NSE:IDEA-EQ',"NSE:SBIN-EQ"],false,1)
+skt.mode(skt.FullMode,1)
+console.log(skt.isConnected())
+// skt.mode(skt.LiteMode,[11,12,13])
+// skt.channelresume(2)
+// skt.unsubscribe(['NSE:IDEA-EQ'],false,1)
+})
+
+skt.on("message",function(message){
+	console.log({"TEST":message})
+})
+
+skt.on("error",function(message){
+	console.log("erroris",message)
+})
+
+skt.on("close",function(){
+    console.log("socket closed")
+})
+skt.connect()
+skt.autoreconnect()

package/sample/index.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title> 
+    <button type="submit" class="id">click here for order socket</button>
+    <button type="submit" class="data_socket">click here for data socket</button>
+    <button type="submit" class="apis">click here for api</button>
+</head>
+<body>
+    
+</body>
+<script type="module" src = './index.js'></script>
+</html>