fyers-api-v3 1.4.2 → 1.6.0

package/apiService/apiService.js

@@ -1,10 +1,20 @@
 "use strict";
 let { Config } = require("../config/config");
 let errorHandler = require("../errorHandler/errorHandler");
-let axios = require("axios")
+const axios = require("axios");
+const https = require('https');
 const crypto = require('crypto');
 let Logger = require("../logger/log.js")
 
+// Create a custom axios instance with keepAlive for connection reuse
+const httpsAgent = new https.Agent({
+    keepAlive: true
+});
+
+const axiosInstance = axios.create({
+    httpsAgent: httpsAgent
+});
+
 /**
  * Class to access Fyers API.
  * @class
@@ -63,6 +73,13 @@ class FyersApi {
          * @type {Logger}
          */
         self.Logger = new Logger(this.LogPath,this.LoggingFlag)
+
+        /**
+         * axios instance for making HTTP requests (shared across all instances).
+         * @type {Object}
+         */
+        self.session = axiosInstance;
+
     }
 
     /**
@@ -122,6 +139,7 @@ class FyersApi {
      * @returns {Object} Object with access token and refresh token if successful
      */
     generate_access_token = async (req) => {
+        let session = this.session;
         var funcname = 'generateAuthCode'
         var logger = this.Logger
         const code_verifier = req.code_verifier || "";
@@ -134,7 +152,7 @@ class FyersApi {
 
             if (code_verifier === "") {
 
-                const access_token = await axios.post(`${Config.SYNC_API}/validate-authcode`, {
+                const access_token = await session.post(`${Config.SYNC_API}/validate-authcode`, {
                     grant_type: "authorization_code",
                     code: req.auth_code,
                     appIdHash: sha256
@@ -144,7 +162,7 @@ class FyersApi {
             }
             else {
 
-                const access_token = await axios.post(`${Config.API}/validate-authcode`, {
+                const access_token = await session.post(`${Config.API}/validate-authcode`, {
                     grant_type: "authorization_code",
                     code_verifier: req.code_verifier,
                     code: req.auth_code,
@@ -167,6 +185,7 @@ class FyersApi {
      * @returns {Promise} returns profile data on resolve or error message and error code on failure
      */
     get_profile = async (req) => {
+        let session = this.session;
         var funcname = 'get_profile'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -174,7 +193,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["get_profile"]
-                await axios.get((url), {
+                await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -198,6 +217,7 @@ class FyersApi {
      * @returns {Promise} returns funds detail on resolve or error message and error code on failure
      */
     get_funds = async (req) => {
+        let session = this.session;
         var funcname = 'get_funds'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -205,7 +225,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["funds"]
-                await axios.get((url), {
+                await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -229,6 +249,7 @@ class FyersApi {
      * @returns {Promise} returns holdings detail on resolve or error message and error code on failure
      */
     get_holdings = async (req) => {
+        let session = this.session;
         var funcname = 'get_holdings'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -236,7 +257,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["holdings"]
-                await axios.get((url), {
+                await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -260,6 +281,7 @@ class FyersApi {
      * @returns {Promise} This invalidates the access token
      */
     logout_user = async (req) => {
+        let session = this.session;
         var funcname = 'logout_user'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -267,7 +289,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["logout"]
-                await axios.post((url), req, {
+                await session.post((url), req, {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -292,6 +314,7 @@ class FyersApi {
      * @returns {Promise} returns orderbook detail on resolve or error message and error code on failure
      */
     get_orders = async (req) => {
+        let session = this.session;
         var funcname = 'get_orders'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -299,7 +322,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["orders"]
-                await axios.get((url), {
+                await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -308,6 +331,8 @@ class FyersApi {
                     .then(Response => {
                         logger.debug(`${funcname} response`, Response.data, funcname)
                         resolve(Response.data)
+                    }).catch(error => {
+                        logger.error(`${funcname} response`, error, funcname)
                     })
             }
             catch (e) {
@@ -323,6 +348,7 @@ class FyersApi {
      * @returns {Promise} returns orderbook detail on resolve or error message and error code on failure
      */
     get_gtt_orders = async (req) => {
+        let session = this.session;
         var funcname = 'get_gtt_orders'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -330,7 +356,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["gtt_orders"]
-                await axios.get((url), {
+                await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -356,6 +382,7 @@ class FyersApi {
      * @returns {Promise} returns orderbook detail of passed order ID on resolve or error message and error code on failure
      */
     get_filtered_orders = async (req) => {
+        let session = this.session;
         var funcname = 'get_filtered_orders'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -363,7 +390,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["orders"] + `?id=${req.order_id}`
-                await axios.get((url), {
+                await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -387,6 +414,7 @@ class FyersApi {
      * @returns {Promise} returns positionbook detail on resolve or error message and error code on failure
      */
     get_positions = async (req) => {
+        let session = this.session;
         var funcname = 'get_positions'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -394,7 +422,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["positions"]
-                await axios.get((url), {
+                await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -418,6 +446,7 @@ class FyersApi {
      * @returns {Promise} returns tradebook detail on resolve or error message and error code on failure
      */
     get_tradebook = async (req) => {
+        let session = this.session;
         var funcname = 'get_tradebook'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -425,7 +454,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["tradebook"]
-                await axios.get((url), {
+                await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -450,6 +479,7 @@ class FyersApi {
      * @returns {Promise} returns orderID of placed order on resolve or error message and error code on failure
      */
     place_order = async (req) => {
+        let session = this.session;
         var funcname = 'place_order'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -457,7 +487,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["orders_sync"]
-                await axios.post((url), req, {
+                await session.post((url), req, {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -483,6 +513,7 @@ class FyersApi {
      * @returns {Promise} returns orderID of placed order on resolve or error message and error code on failure
      */
     place_gtt_order = async (req) => {
+        let session = this.session;
         var funcname = 'place_gtt_order'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -490,7 +521,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["gtt_orders_sync"]
-                await axios.post((url), req, {
+                await session.post((url), req, {
                     headers: {
                         Authorization: AuthrizationToken,
                     }
@@ -513,6 +544,7 @@ class FyersApi {
      * @returns {Promise} returns orderID of placed order on resolve or error message and error code on failure
      */
     place_multileg_order = async (req) => {
+        let session = this.session;
         var funcname = 'place_multileg_order'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -520,7 +552,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["multileg_orders_sync"]
-                await axios.post((url), req, {
+                await session.post((url), req, {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -546,6 +578,7 @@ class FyersApi {
      * @returns {Promise} returns orderID of all placed and if they are failed or successful on resolve or error message and error code on failure
      */
     place_multi_order = async (req) => {
+        let session = this.session;
         var funcname = 'place_multi_order'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -553,7 +586,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["multi_orders"]
-                await axios.post((url), req, {
+                await session.post((url), req, {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -578,6 +611,7 @@ class FyersApi {
      * @returns {Promise} returns orderID of passed order ID and if modification was successful or not resolve or error message and error code on failure
      */
     modify_order = async (req) => {
+        let session = this.session;
         var funcname = 'modify_order'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -585,7 +619,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["orders_sync"]
-                await axios.patch((url), req, {
+                await session.patch((url), req, {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -610,6 +644,7 @@ class FyersApi {
      * @returns {Promise} returns orderID of passed order ID and if modification was successful or not resolve or error message and error code on failure
      */
     gtt_modify_order = async (req) => {
+        let session = this.session;
         var funcname = 'gtt_modify_order'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -617,7 +652,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["gtt_orders_sync"]
-                await axios.patch((url), req, {
+                await session.patch((url), req, {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -642,6 +677,7 @@ class FyersApi {
      * @returns {Promise} returns orderID of passed order ID and if modification was successful or not on resolve or error message and error code on failure
      */
     modify_multi_order = async (req) => {
+        let session = this.session;
         var funcname = 'modify_multi_order'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -649,7 +685,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["multi_orders"]
-                await axios.patch((url), req, {
+                await session.patch((url), req, {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -674,6 +710,7 @@ class FyersApi {
      * @returns {Promise} returns orderID of passed order ID and if cancellation was successful or not on resolve or error message and error code on failure
      */
     cancel_order = async (req) => {
+        let session = this.session;
         var funcname = 'cancel_order'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -681,7 +718,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["orders_sync"]
-                await axios.delete((url), {
+                await session.delete((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -707,6 +744,7 @@ class FyersApi {
      * @returns {Promise} returns orderID of passed order ID and if cancellation was successful or not on resolve or error message and error code on failure
      */
     gtt_cancel_order = async (req) => {
+        let session = this.session;
         var funcname = 'gtt_cancel_order'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -714,7 +752,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["gtt_orders_sync"]
-                await axios.delete((url), {
+                await session.delete((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -740,6 +778,7 @@ class FyersApi {
      * @returns {Promise} returns orderID of passed order ID and if cancellation was successful or not on resolve or error message and error code on failure
      */
     cancel_multi_order = async (req) => {
+        let session = this.session;
         var funcname = 'cancel_multi_order'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -747,7 +786,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["multi_orders"]
-                await axios.delete((url), {
+                await session.delete((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -773,6 +812,7 @@ class FyersApi {
      * @returns {Promise} returns success message on resolve or error message and error code on failure
      */
     exit_position = async (req) => {
+        let session = this.session;
         var funcname = 'exit_position'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -780,7 +820,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["positions"]
-                await axios.delete((url), {
+                await session.delete((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -806,6 +846,7 @@ class FyersApi {
      * @returns {Promise} returns success message on resolve or error message and error code on failure
      */
     convert_position = async (req) => {
+        let session = this.session;
         var funcname = 'convert_position'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -813,7 +854,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.SYNC_API + Config["positions"]
-                await axios.post((url), req, {
+                await session.post((url), req, {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -837,6 +878,7 @@ class FyersApi {
      * @returns {Promise} returns success message on resolve or error message and error code on failure
      */
     market_status = async (req) => {
+        let session = this.session;
         var funcname = 'market_status'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -844,7 +886,7 @@ class FyersApi {
         return new Promise(async function (resolve, reject) {
             try {
                 var url = Config.data_Api1 + Config["marketStatus"]
-                const profile = await axios.get((url), {
+                const profile = await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -869,6 +911,7 @@ class FyersApi {
      * @returns {Promise} returns success message on resolve or error message and error code on failure
      */
     getHistory = async (req) => {
+        let session = this.session;
         var funcname = 'getHistory'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -877,7 +920,7 @@ class FyersApi {
             try {
                 var url = Config.data_Api1 + Config["history"]
                 url = generateUrl(url, req)
-                await axios.get((url), {
+                await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -902,6 +945,7 @@ class FyersApi {
      * @returns {Promise} returns success message on resolve or error message and error code on failure
      */
     getQuotes = async (req) => {
+        let session = this.session;
         var funcname = 'getQuotes'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -917,7 +961,7 @@ class FyersApi {
                 var data = { "symbols": symbolstring }
                 const urlParams = new URLSearchParams(data);
                 url = url + '?' + urlParams
-                await axios.get((url), {
+                await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -942,6 +986,7 @@ class FyersApi {
      * @returns {Promise} returns success message on resolve or error message and error code on failure
      */
     getMarketDepth = async (req) => {
+        let session = this.session;
         var funcname = 'getQuotes'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -957,7 +1002,7 @@ class FyersApi {
                 var data = { "symbol": symbolstring, "ohlcv_flag": req.ohlcv_flag }
                 const urlParams = new URLSearchParams(data);
                 url = url + '?' + urlParams
-                await axios.get((url), {
+                await session.get((url), {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -982,6 +1027,7 @@ class FyersApi {
      * @returns {Promise} returns success message on resolve or error message and error code on failure
      */
     getOptionChain = async (req) => {
+        let session = this.session;
         var funcname = 'getOptionChain'
         var logger = this.Logger
         let AuthrizationToken = this.AccessToken
@@ -990,7 +1036,624 @@ class FyersApi {
             try {
                 var url = Config.data_Api1 + Config["optionChain"]
                 url = generateUrl(url, req)
-                await axios.get((url), {
+                await session.get((url), {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to get price alert data.
+     * @param {Object} [req] - optional request parameters for price alert (query parameters)
+     * @param {string} [req.archive] - Set to "1" to get archived alerts, default is "0"
+     * @returns {Promise<Object>} returns price alert data on resolve or error message and error code on failure
+     * Response structure: {code: 200, message: "", s: "ok", data: {[alertId]: {fyToken: string, symbol: string, alert: {comparisonType, condition, name, type, value, status, createdAt, createdEpoch, ...}}}}
+     * Example: {code: 200, message: "", s: "ok", data: {"5682484": {fyToken: "10100000008080", symbol: "NSE:SILVERBEES-EQ", alert: {...}}}}
+     */
+    getPriceAlert = async (req) => {
+        let session = this.session;
+        var funcname = 'getPriceAlert'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["priceAlert"]
+                if (req && Object.keys(req).length > 0) {
+                    url = generateUrl(url, req)
+                }
+                await session.get((url), {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to create price alert.
+     * @param {Object} req - request body for creating price alert
+     * @param {string} req.agent - Agent identifier (e.g., "fyers-api")
+     * @param {number} req["alert-type"] - Alert type (e.g., 1)
+     * @param {string} req.name - Alert name (e.g., "gold alert")
+     * @param {string} req.symbol - Symbol (e.g., "NSE:GOLDBEES-EQ")
+     * @param {string} req.comparisonType - Comparison type (e.g., "LTP")
+     * @param {string} req.condition - Condition (e.g., "GT", "LT", "LTE", "GTE")
+     * @param {string} req.value - Alert value (e.g., "99999")
+     * @param {string} [req.notes] - Optional notes
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    createPriceAlert = async (req) => {
+        let session = this.session;
+        var funcname = 'createPriceAlert'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["priceAlert"]
+                await session.post((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to modify price alert.
+     * @param {Object} req - request body for modifying price alert
+     * @param {string} req.alertId - Alert ID to modify (e.g., "3871537")
+     * @param {string} req.agent - Agent identifier (e.g., "fyers-api")
+     * @param {number} req["alert-type"] - Alert type (e.g., 1)
+     * @param {string} req.name - Alert name (e.g., "silver bees")
+     * @param {string} req.symbol - Symbol (e.g., "NSE:GOLDBEES-EQ")
+     * @param {string} req.comparisonType - Comparison type (e.g., "OPEN", "LTP")
+     * @param {string} req.condition - Condition (e.g., "GT", "LT", "LTE", "GTE")
+     * @param {number} req.value - Alert value (e.g., 299)
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    modifyPriceAlert = async (req) => {
+        let session = this.session;
+        var funcname = 'modifyPriceAlert'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["priceAlert"]
+                await session.put((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to toggle price alert (enable/disable).
+     * @param {Object} req - request body for toggling price alert
+     * @param {string} req.alertId - Alert ID to toggle (e.g., "3871590")
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    togglePriceAlert = async (req) => {
+        let session = this.session;
+        var funcname = 'togglePriceAlert'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["togglePriceAlert"]
+                await session.put((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to delete price alert.
+     * @param {Object} req - request body for deleting price alert
+     * @param {string} req.alertId - Alert ID to delete (e.g., "3871519")
+     * @param {string} req.agent - Agent identifier (e.g., "fyers-api")
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    deletePriceAlert = async (req) => {
+        let session = this.session;
+        var funcname = 'deletePriceAlert'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["priceAlert"]
+                await session.delete((url), {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    },
+                    data: req
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to create smart order limit.
+     * @param {Object} req - request body for create smart order limit
+     * @param {string} req.symbol - Symbol (e.g., "NSE:SBIN-EQ")
+     * @param {number} req.side - Side (1 for Buy, -1 for Sell)
+     * @param {number} req.qty - Quantity
+     * @param {string} req.productType - Product type (e.g., "CNC", "INTRADAY")
+     * @param {number} req.limitPrice - Limit price
+     * @param {number} [req.stopPrice] - Stop price (optional)
+     * @param {number} req.orderType - Order type
+     * @param {number} req.endTime - End time (Unix timestamp)
+     * @param {number} req.hpr - High price range
+     * @param {number} req.lpr - Low price range
+     * @param {number} req.mpp - Maximum price percentage
+     * @param {number} req.onExp - On expiry action
+     * @param {number} [req.type] - Type (optional)
+     * @param {string} [req.validity] - Validity (e.g., "DAY")
+     * @param {number} [req.disclosedQty] - Disclosed quantity (optional)
+     * @param {boolean} [req.offlineOrder] - Offline order flag (optional)
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    createSmartOrderLimit = async (req) => {
+        let session = this.session;
+        var funcname = 'createSmartOrderLimit'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["createSmartorderLimit"]
+                await session.post((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+
+    /**
+     * use to create smart order step.
+     * @param {Object} req - request body for create smart order step
+     * @param {string} req.symbol - Symbol (e.g., "NSE:SBIN-EQ")
+     * @param {number} req.side - Side (1 for Buy, -1 for Sell)
+     * @param {number} req.qty - Total quantity
+     * @param {string} req.productType - Product type (e.g., "CNC", "INTRADAY")
+     * @param {number} req.initQty - Initial quantity
+     * @param {number} req.avgqty - Average quantity
+     * @param {number} req.avgdiff - Average difference
+     * @param {number} req.direction - Direction
+     * @param {number} req.limitPrice - Limit price
+     * @param {number} req.orderType - Order type
+     * @param {number} req.startTime - Start time (Unix timestamp)
+     * @param {number} req.endTime - End time (Unix timestamp)
+     * @param {number} req.hpr - High price range
+     * @param {number} req.lpr - Low price range
+     * @param {number} req.mpp - Maximum price percentage
+     * @param {number} [req.type] - Type (optional)
+     * @param {number} [req.stopPrice] - Stop price (optional)
+     * @param {string} [req.validity] - Validity (e.g., "DAY") (optional)
+     * @param {number} [req.disclosedQty] - Disclosed quantity (optional)
+     * @param {boolean} [req.offlineOrder] - Offline order flag (optional)
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    createSmartOrderStep = async (req) => {
+        let session = this.session;
+        var funcname = 'createSmartOrderStep'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["createSmartorderStep"]
+                await session.post((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to create smart order SIP.
+     * @param {Object} req - request body for create smart order SIP
+     * @param {string} req.symbol - Symbol (e.g., "NSE:SBIN-EQ")
+     * @param {number} req.side - Side (1 for Buy, -1 for Sell)
+     * @param {number} req.amount - Amount for SIP
+     * @param {string} req.productType - Product type (e.g., "CNC", "INTRADAY")
+     * @param {number} req.freq - Frequency
+     * @param {number} req.sip_day - SIP day
+     * @param {boolean} req.imd_start - Immediate start flag
+     * @param {number} req.endTime - End time (Unix timestamp)
+     * @param {number} req.hpr - High price range
+     * @param {number} req.lpr - Low price range
+     * @param {number} req.step_up_freq - Step up frequency
+     * @param {number} req.step_up_amount - Step up amount
+     * @param {number} [req.qty] - Quantity (optional)
+     * @param {number} [req.type] - Type (optional)
+     * @param {number} [req.limitPrice] - Limit price (optional)
+     * @param {number} [req.stopPrice] - Stop price (optional)
+     * @param {string} [req.validity] - Validity (e.g., "DAY") (optional)
+     * @param {number} [req.disclosedQty] - Disclosed quantity (optional)
+     * @param {boolean} [req.offlineOrder] - Offline order flag (optional)
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    createSmartOrderSIP = async (req) => {
+        let session = this.session;
+        var funcname = 'createSmartOrderSIP'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["createSmartorderSip"]
+                await session.post((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to create smart order trail.
+     * @param {Object} req - request body for create smart order trail
+     * @param {string} req.symbol - Symbol (e.g., "NSE:SBIN-EQ")
+     * @param {number} req.side - Side (1 for Buy, -1 for Sell)
+     * @param {number} req.qty - Quantity
+     * @param {string} req.productType - Product type (e.g., "CNC", "INTRADAY")
+     * @param {number} req.stopPrice - Stop price
+     * @param {number} req.jump_diff - Jump difference
+     * @param {number} req.orderType - Order type
+     * @param {number} req.mpp - Maximum price percentage
+     * @param {number} [req.type] - Type (optional)
+     * @param {number} [req.limitPrice] - Limit price (optional)
+     * @param {string} [req.validity] - Validity (e.g., "DAY") (optional)
+     * @param {number} [req.disclosedQty] - Disclosed quantity (optional)
+     * @param {boolean} [req.offlineOrder] - Offline order flag (optional)
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    createSmartOrderTrail = async (req) => {
+        let session = this.session;
+        var funcname = 'createSmartOrderTrail'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["createSmartorderTrail"]
+                await session.post((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to modify smart order.
+     * @param {Object} req - request body for modify smart order
+     * @param {string} req.flowId - Flow ID of the smart order to modify
+     * @param {number} [req.qty] - New quantity (optional)
+     * @param {number} [req.limitPrice] - New limit price (optional)
+     * @param {number} [req.endTime] - New end time (Unix timestamp) (optional)
+     * @param {number} [req.stopPrice] - New stop price (optional)
+     * @param {number} [req.hpr] - New high price range (optional)
+     * @param {number} [req.lpr] - New low price range (optional)
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    modifySmartOrder = async (req) => {
+        let session = this.session;
+        var funcname = 'modifySmartOrder'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["modifySmartorder"]
+                await session.patch((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to cancel smart order.
+     * @param {Object} req - request body for cancel smart order
+     * @param {string} req.flowId - Flow ID of the smart order to cancel
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    cancelSmartOrder = async (req) => {
+        let session = this.session;
+        var funcname = 'cancelSmartOrder'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["cancelSmartorder"]
+                await session.delete((url), {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    },
+                    data: req
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to pause smart order.
+     * @param {Object} req - request body for pause smart order
+     * @param {string} req.flowId - Flow ID of the smart order to pause
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    pauseSmartOrder = async (req) => {
+        let session = this.session;
+        var funcname = 'pauseSmartOrder'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["pauseSmartorder"]
+                await session.patch((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to resume smart order.
+     * @param {Object} req - request body for resume smart order
+     * @param {string} req.flowId - Flow ID of the smart order to resume
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    resumeSmartOrder = async (req) => {
+        let session = this.session;
+        var funcname = 'resumeSmartOrder'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["resumeSmartorder"]
+                await session.patch((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to get smart order book with filter.
+     * @param {Object} [req] - optional request parameters for filtering smart order book
+     * @param {string[]} [req.exchange] - Filter by exchange (e.g., ["NSE"])
+     * @param {number[]} [req.side] - Filter by side (1 for Buy, -1 for Sell) (e.g., [1, -1])
+     * @param {number[]} [req.flowtype] - Filter by flow type (e.g., [1, 2])
+     * @param {string[]} [req.product] - Filter by product type (e.g., ["CNC", "INTRADAY"])
+     * @param {number[]} [req.messageType] - Filter by message type (e.g., [1, 2])
+     * @param {string} [req.search] - Search string (e.g., "SBIN")
+     * @param {string} [req.sort_by] - Sort by field (e.g., "CreatedTime")
+     * @param {number} [req.ord_by] - Order by (1 for ascending, -1 for descending)
+     * @param {number} [req.page_no] - Page number
+     * @param {number} [req.page_size] - Page size
+     * @returns {Promise} returns smart order book on resolve or error message and error code on failure
+     */
+    getSmartOrderBookWithFilter = async (req) => {
+        let session = this.session;
+        var funcname = 'getSmartOrderBookWithFilter'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["smartorderOrderBook"]
+                await session.get((url), {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    },
+                    params: req
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to create smart exit trigger.
+     * @param {Object} req - request body for create smart exit trigger
+     * @param {string} req.name - Strategy name (e.g., "Alert Only Strategy")
+     * @param {number} req.type - Trigger type (1: Only Alert, 2: Exit with Alert, 3: Exit with Alert + Wait for Recovery)
+     * @param {number} req.profitRate - Profit rate threshold
+     * @param {number} req.lossRate - Loss rate threshold (negative value)
+     * @param {number} [req.waitTime] - Wait time in minutes (required for type 3)
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    createSmartExitTrigger = async (req) => {
+        let session = this.session;
+        var funcname = 'createSmartExitTrigger'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["smartExitTrigger"]
+                await session.post((url), req, {
                     headers: {
                         Authorization: AuthrizationToken,
                         version: vers
@@ -1008,8 +1671,119 @@ class FyersApi {
             }
         })
     }
-}
 
+    /**
+     * use to get smart exit trigger.
+     * @param {Object} [req] - optional request parameters for getting smart exit trigger
+     * @param {string} [req.flowId] - Filter by flow ID (optional)
+     * @returns {Promise} returns smart exit trigger details on resolve or error message and error code on failure
+     */
+    getSmartExitTrigger = async (req) => {
+        let session = this.session;
+        var funcname = 'getSmartExitTrigger'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["smartExitTrigger"]
+                await session.get((url), {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    },
+                    params: req
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to update smart exit trigger.
+     * @param {Object} req - request body for update smart exit trigger
+     * @param {string} req.flowId - Flow ID of the smart exit trigger to update
+     * @param {number} [req.profitRate] - New profit rate threshold (optional)
+     * @param {number} [req.lossRate] - New loss rate threshold (optional, negative value)
+     * @param {number} [req.type] - New trigger type (optional, 1: Only Alert, 2: Exit with Alert, 3: Exit with Alert + Wait for Recovery)
+     * @param {string} [req.name] - New strategy name (optional)
+     * @param {number} [req.waitTime] - New wait time in minutes (optional, required for type 3)
+     * @param {number} [req.triggerPrice] - Trigger price (optional)
+     * @param {number} [req.stopLoss] - Stop loss price (optional)
+     * @param {number} [req.takeProfit] - Take profit price (optional)
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    updateSmartExitTrigger = async (req) => {
+        let session = this.session;
+        var funcname = 'updateSmartExitTrigger'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["smartExitTrigger"]
+                await session.put((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+
+    /**
+     * use to activate/deactivate smart exit trigger.
+     * @param {Object} req - request body for activate/deactivate smart exit trigger
+     * @param {string} req.flowId - Flow ID of the smart exit trigger to activate/deactivate
+     * @returns {Promise} returns success message on resolve or error message and error code on failure
+     */
+    activateDeactivateSmartExitTrigger = async (req) => {
+        let session = this.session;
+        var funcname = 'activateSmartExitTrigger'
+        var logger = this.Logger
+        let AuthrizationToken = this.AccessToken
+        let vers = this.Version
+        return new Promise(async function (resolve, reject) {
+            try {
+                var url = Config.SYNC_API + Config["activateSmartExitTrigger"]
+                await session.post((url), req, {
+                    headers: {
+                        Authorization: AuthrizationToken,
+                        version: vers
+                    }
+                })
+                    .then(Response => {
+                        logger.debug(`${funcname} response`, Response.data, funcname)
+                        resolve(Response.data)
+                    })
+            }
+            catch (e) {
+                var err = new errorHandler(e).getError()
+                logger.error(`${funcname} response`, { "Error": err, "inputs": req }, funcname)
+                reject(err)
+            }
+        })
+    }
+}
+     
 function generateUrl(url, queryObject) {
     let finalUrl = url + "?";
     for (let key in queryObject) {
@@ -1024,3 +1798,4 @@ function getSHA256Hash(inputString) {
     return hash.digest('hex');
 }
 module.exports = FyersApi;
+module.exports.axiosInstance = axiosInstance;