shoonya-sdk 0.3.1

package/dist/shoonya-sdk.js

@@ -0,0 +1,595 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/shoonya-sdk.ts
+var shoonya_sdk_exports = {};
+__export(shoonya_sdk_exports, {
+  Shoonya: () => Shoonya
+});
+module.exports = __toCommonJS(shoonya_sdk_exports);
+
+// src/utils/sha256.ts
+var import_node_crypto = __toESM(require("crypto"));
+function sha256(data) {
+  const hash = import_node_crypto.default.createHash("sha256");
+  return hash.update(data, "utf8").digest("hex");
+}
+__name(sha256, "sha256");
+
+// src/paths.ts
+var paths = {
+  login: "QuickAuth",
+  logout: "Logout",
+  forgotPassword: "ForgotPassword",
+  changePassword: "Changepwd",
+  watchlist: "MWList",
+  getWatchlist: "MarketWatch",
+  searchScrip: "SearchScrip",
+  userInfo: "UserDetails",
+  clientInfo: "ClientDetails",
+  quotes: "GetQuotes",
+  addScripToWL: "AddMultiScripsToMW",
+  removeScripFromWL: "DeleteMultiMWScrips",
+  securityInfo: "GetSecurityInfo",
+  placeOrder: "PlaceOrder",
+  modifyOrder: "ModifyOrder",
+  cancelOrder: "CancelOrder",
+  exitSNOOrder: "ExitSNOOrder",
+  historicData: "TPSeries",
+  optionChain: "GetOptionChain",
+  orderBook: "OrderBook"
+};
+
+// src/shoonya-sdk.ts
+var import_ws = require("ws");
+var import_events = require("events");
+var import_node_cron = __toESM(require("node-cron"));
+
+// src/utils/logger.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var Logger = class {
+  static {
+    __name(this, "Logger");
+  }
+  logPath;
+  maxSize;
+  /**
+   *
+   * @param logPath path of the log file
+   * @param maxSize max size a log file should have (in bytes)
+   */
+  constructor(logPath, maxSize) {
+    this.logPath = logPath;
+    this.maxSize = maxSize;
+    if (!(0, import_fs.existsSync)(this.logPath)) {
+      (0, import_fs.mkdirSync)((0, import_path.dirname)(this.logPath), { recursive: true });
+      (0, import_fs.writeFileSync)(this.logPath, "", "utf8");
+    }
+  }
+  checkLogSize() {
+    const dirName = (0, import_path.dirname)(this.logPath);
+    try {
+      const stats = (0, import_fs.statSync)(this.logPath);
+      if (stats.size >= this.maxSize) {
+        const rotatedPath = (0, import_path.join)(dirName, `log_${Date.now().toString()}.log`);
+        this.logPath = rotatedPath;
+        (0, import_fs.writeFileSync)(rotatedPath, "", "utf-8");
+      }
+    } catch (err) {
+      throw new Error("file not found");
+    }
+    this.deleteOldestFile();
+  }
+  log(message, type = "INFO") {
+    this.checkLogSize();
+    const logMessage = `${type}: [${(/* @__PURE__ */ new Date()).toISOString()}]: ${message}
+`;
+    (0, import_fs.appendFileSync)(this.logPath, logMessage, { encoding: "utf-8" });
+  }
+  getRecentLog() {
+    const dir = (0, import_fs.readdirSync)((0, import_path.dirname)(this.logPath), { recursive: true });
+    const file = (0, import_fs.readFileSync)(dir.at(-1), "utf8");
+    return file;
+  }
+  deleteOldestFile() {
+    const dirName = (0, import_path.dirname)(this.logPath);
+    const files = (0, import_fs.readdirSync)(dirName);
+    const currentDate = /* @__PURE__ */ new Date();
+    const sevenDaysAgo = (/* @__PURE__ */ new Date()).setDate(currentDate.getDate() - 7);
+    for (const file of files) {
+      const filePath = (0, import_path.join)(dirName, file);
+      const stat = (0, import_fs.statSync)(filePath);
+      if (stat.birthtimeMs < sevenDaysAgo) {
+        (0, import_fs.unlinkSync)(filePath);
+      }
+    }
+  }
+};
+var logger_default = Logger;
+
+// src/shoonya-sdk.ts
+var import_totp_generator = __toESM(require("totp-generator"));
+var Shoonya = class extends import_events.EventEmitter {
+  static {
+    __name(this, "Shoonya");
+  }
+  accessToken;
+  userId;
+  logger;
+  logging = false;
+  httpBaseUrl = "https://api.shoonya.com/NorenWClientTP/";
+  wsBaseUrl = "wss://api.shoonya.com/NorenWSTP/";
+  ws;
+  connectTimer;
+  disconnectTimer;
+  accountId;
+  twoFa;
+  password;
+  apiKey;
+  cronJobRunning = false;
+  scripList;
+  constructor(options) {
+    const { logging = false } = options || {};
+    super({ captureRejections: true });
+    this.userId = "";
+    this.accessToken = "";
+    this.accountId = this.userId;
+    this.logging = logging;
+    if (logging) {
+      this.logger = new logger_default(
+        `./logs/log_${Date.now().toString()}.log`,
+        1024 * 10
+        //1KB * 10 = 10KB
+      );
+    }
+  }
+  async request(path, body) {
+    const jData = `jData=${JSON.stringify(body.data)}${body.key ? "&jKey=" + body.key : ""}`;
+    try {
+      const data = await fetch(this.httpBaseUrl + paths[path], {
+        method: "POST",
+        body: jData,
+        keepalive: true
+      }).then((res) => {
+        return res.json();
+      });
+      return data;
+    } catch (err) {
+      if (this.logging) {
+        const errMessage = "Failed to fetch data from api while performing: " + path;
+        this.logger.log(errMessage, "ERROR");
+        console.error(errMessage);
+      }
+      console.error(err);
+    }
+  }
+  // Rest API
+  /**
+   *
+   * @param credentials User Credential (username, password, appkeys etc.)
+   * @returns user information and access token
+   */
+  async login(rawCred) {
+    const cred = {
+      apkversion: "1.0.0",
+      uid: rawCred.userId,
+      pwd: sha256(rawCred.password),
+      factor2: (0, import_totp_generator.default)(rawCred.twoFa),
+      vc: rawCred?.vendorCode || rawCred.userId + "_U",
+      appkey: sha256(`${rawCred.userId}|${rawCred.apiKey}`),
+      imei: rawCred?.imei || "api",
+      source: "API"
+    };
+    try {
+      const req = await this.request("login", { data: cred });
+      this.userId = req.uid;
+      this.accessToken = req.susertoken;
+      this.accountId = this.userId;
+      this.apiKey = rawCred.apiKey;
+      this.password = rawCred.password;
+      this.twoFa = rawCred.twoFa;
+      return req;
+    } catch (err) {
+      if (this.logging) {
+        const fallBackMessage = "Attempted to login but it failed";
+        const errMessage = err?.message || fallBackMessage;
+        this.logger.log(errMessage, "ERROR");
+        console.error(errMessage);
+      }
+      console.error("Login Failed", err);
+    }
+  }
+  /**
+   * @param query scrip name (BankNifty, Sensex etc.)
+   * @param exchange exchange name (NSE, BSE etc.)
+   * @returns
+   */
+  async searchScrip(query, exchange) {
+    if (!this.accessToken) {
+      throw "Login First before seaching";
+    }
+    const data = {
+      uid: this.userId,
+      stext: query,
+      exch: exchange
+    };
+    return this.request("searchScrip", {
+      data,
+      key: this.accessToken
+    });
+  }
+  async getWatchlistsName() {
+    if (!this.accessToken) {
+      throw "Login First before accessing watchlists";
+    }
+    return this.request("watchlist", {
+      data: { uid: this.userId },
+      key: this.accessToken
+    });
+  }
+  async getWatchlist(listName) {
+    if (!this.accessToken) {
+      throw "Login First before accessing watchlists";
+    }
+    return this.request("getWatchlist", {
+      data: { uid: this.userId, wlname: listName },
+      key: this.accessToken
+    });
+  }
+  async forgetPassword(PAN, DOB) {
+    const data = {
+      uid: this.userId,
+      pan: PAN,
+      dob: DOB
+    };
+    return this.request("forgotPassword", { data });
+  }
+  /**
+   *
+   * @param oldPass sha256 of old pass
+   * @param newPass new password in plain text
+   * @returns
+   */
+  async changePassword(oldPass, newPass) {
+    const data = {
+      uid: this.userId,
+      oldpwd: oldPass,
+      pwd: newPass
+    };
+    return this.request("changePassword", { data });
+  }
+  async getUserDetails() {
+    return this.request("userInfo", {
+      data: { uid: this.userId },
+      key: this.accessToken
+    });
+  }
+  /**
+   * @param brokerId logged in user's brokers Name / Id
+   * @returns
+   */
+  async getClientDetails(brokerId) {
+    const data = {
+      uid: this.userId,
+      actid: this.accountId,
+      brkname: brokerId
+    };
+    return this.request("clientInfo", { data, key: this.accessToken });
+  }
+  async getQuotes(exchange, contractToken) {
+    const data = {
+      uid: this.userId,
+      exch: exchange,
+      token: contractToken
+    };
+    return this.request("quotes", { data, key: this.accessToken });
+  }
+  /**
+   *
+   * @param listName name of watchlist in which user want to add script
+   * @param scrips list of the scrip
+   * @returns
+   */
+  async addScripToWatchList(listName, scrips) {
+    const data = {
+      uid: this.userId,
+      wlname: listName,
+      scrips: scrips.join("#")
+    };
+    return this.request("addScripToWL", { data, key: this.accessToken });
+  }
+  /**
+   *
+   * @param listName name of watchlist in which user want to add script
+   * @param scrips list of the scrip
+   * @returns
+   */
+  async removeScripFromWatchList(listName, scrips) {
+    const data = {
+      uid: this.userId,
+      wlname: listName,
+      scrips: scrips.join("#")
+    };
+    return this.request("removeScripFromWL", { data, key: this.accessToken });
+  }
+  async getSecurityInfo(exchange, contractToken) {
+    const data = {
+      uid: this.userId,
+      exch: exchange,
+      token: contractToken
+    };
+    return this.request("securityInfo", { data, key: this.accessToken });
+  }
+  async placeOrder(details) {
+    const data = {
+      uid: details.uid || this.userId,
+      actid: details.actid || this.accountId,
+      ...details
+    };
+    return this.request("placeOrder", {
+      data,
+      key: this.accessToken
+    });
+  }
+  async modifyOrder(orderDetail) {
+    orderDetail.uid ??= this.userId;
+    orderDetail.actid ??= this.accountId;
+    return this.request("modifyOrder", {
+      data: orderDetail,
+      key: this.accessToken
+    });
+  }
+  async cancelOrder(orderNo) {
+    return this.request("cancelOrder", {
+      data: {
+        uid: this.userId,
+        norenordno: orderNo
+      },
+      key: this.accessToken
+    });
+  }
+  /**
+   *
+   * @param orderNo Noren order number, which needs to be modified
+   * @param product Allowed for only H and B products (Cover order and bracket order)
+   * @returns
+   */
+  async exitSNOOrder(orderNo, product) {
+    const data = {
+      norenordno: orderNo,
+      prd: product,
+      uid: this.userId
+    };
+    return this.request("exitSNOOrder", { data, key: this.accessToken });
+  }
+  async getHistoricData(option) {
+    const data = { uid: this.userId, ...option };
+    return this.request("historicData", { data, key: this.accessToken });
+  }
+  async getOptionChain(option) {
+    const data = {
+      uid: this.userId,
+      tsym: encodeURIComponent(option.tradingSymbol),
+      exch: option.exchange,
+      strprc: option.midPrice,
+      cnt: option.count
+    };
+    return this.request("optionChain", {
+      data,
+      key: this.accessToken
+    });
+  }
+  async orderBook(prd) {
+    const data = { uid: this.userId, prd };
+    return this.request("orderBook", {
+      data,
+      key: this.accessToken
+    });
+  }
+  /**
+   * Its a custom method which will return token number of option
+   * it can be used to start websocket connection to that tokenƒ
+   *
+   * @param params info about symbol
+   * @returns
+   */
+  async getOptionToken(params) {
+    const { strikePrice, exchange = "NFO", count = "5" } = params;
+    const optionType = params.optionType.at(0);
+    const symbol = params.symbol.toUpperCase();
+    for await (const expiry of this.getNext7FormattedDate()) {
+      const optionToPick = `${symbol}${expiry}${optionType}${strikePrice}`;
+      const optionChain = await this.getOptionChain({
+        count,
+        exchange,
+        midPrice: strikePrice.toString(),
+        tradingSymbol: optionToPick
+      });
+      if (optionChain.stat === "Not_Ok")
+        continue;
+      for (const { tsym, token } of optionChain.values) {
+        if (tsym === optionToPick) {
+          return { token, exchange, tsym };
+        }
+      }
+    }
+    return null;
+  }
+  getFormattedExpiry(date) {
+    const stringDate = date.toString();
+    const [_, month, day, year] = stringDate.split(" ");
+    const newMonth = month.toUpperCase();
+    const newYear = year.slice(2);
+    return `${day}${newMonth}${newYear}`;
+  }
+  getNext7FormattedDate() {
+    const dates = [];
+    let currentDate = /* @__PURE__ */ new Date();
+    for (let i = 0; i < 7; i++) {
+      const formattedDate = this.getFormattedExpiry(currentDate);
+      dates.push(formattedDate);
+      currentDate = new Date(currentDate.setDate(currentDate.getDate() + 1));
+    }
+    return dates;
+  }
+  // WebSocket API
+  connectWS() {
+    if (this.ws && (this.ws.readyState === 0 || this.ws.readyState === 1)) {
+      return;
+    }
+    this.ws = new import_ws.WebSocket(this.wsBaseUrl);
+    this.ws.addEventListener("open", () => {
+      let msg = {
+        t: "c",
+        uid: this.userId,
+        actid: this.accountId,
+        source: "API",
+        susertoken: this.accessToken
+      };
+      this.ws.send(JSON.stringify(msg));
+      if (this.cronJobRunning) {
+        this.subscribe(this.scripList);
+        return;
+      }
+      import_node_cron.default.schedule("43,00 3,10 * * 1-5", async () => {
+        this.cronJobRunning = true;
+        const hour = (/* @__PURE__ */ new Date()).getUTCHours();
+        const min = (/* @__PURE__ */ new Date()).getUTCMinutes();
+        if (hour === 3 && min === 43) {
+          try {
+            const cred = {
+              apiKey: this.apiKey,
+              password: this.password,
+              twoFa: this.twoFa,
+              userId: this.userId
+            };
+            await this.login(cred);
+            this.connectWS();
+          } catch (err) {
+            console.error(err);
+            const errMessage = `Token refreshing failed. ERR: ${err.message}`;
+            this.logging && this.logger.log(errMessage, "ERROR");
+            this.emit("stopped", errMessage);
+          }
+        }
+        if (hour === 10 && min === 0) {
+          this.disconnect();
+        }
+      });
+    });
+    this.ws.addEventListener("message", (e) => {
+      const result = JSON.parse(e.data.toString());
+      if (result.t === "dk") {
+        this.logging && this.logger.log(`Subscribed to ${result.ts}. Listening...`);
+      }
+      if (result.lp && result.t === "df") {
+        this.emit("priceUpdate", result);
+      }
+      if (result.t === "ok") {
+        this.emit("orderUpdate", result);
+      }
+      if (result.t === "ck") {
+        clearTimeout(this.connectTimer);
+        this.connectTimer = setTimeout(() => {
+          this.emit("connect", e);
+          this.logging && this.logger.log("Connected with Shoonya API! Streaming Data...");
+        }, 3e3);
+        return;
+      }
+      clearTimeout(this.disconnectTimer);
+      this.disconnectTimer = setTimeout(() => {
+        const day = (/* @__PURE__ */ new Date()).getDay();
+        if (day in [5, 6])
+          return;
+        const err = "API have stopped to respond! there could be a problem with API or market has closed";
+        this.logging && this.logger.log(err, "WARN");
+        this.emit("stopped", err);
+      }, 6e4 * 60 * 18 - 15e3);
+    });
+  }
+  /**
+   *
+   * subscribes for list of scrip by which WS returns them every time their price changes.
+   *
+   * `searchScrip` method can be used to get scripToken from scripName
+   * @param scripList scrip list requires list of scrip name in format of `exchangeName|scripToken`
+   */
+  subscribe(scripList) {
+    const msg = {
+      t: "d",
+      // depth subscription
+      k: scripList.join("#")
+    };
+    this.scripList = scripList;
+    if (this.ws) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  unsubscribe(scripList) {
+    const msg = {
+      t: "ud",
+      // unsubcribe depth subscription
+      k: scripList.join("#")
+    };
+    if (this.ws) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  subscribeOrderUpdate() {
+    const msg = {
+      t: "o",
+      // order update
+      actid: this.userId
+    };
+    if (this.ws) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  unsubscribeOrderUpdate() {
+    const msg = {
+      t: "ud"
+      // unsubscribe order update
+    };
+    if (this.ws) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  disconnect() {
+    if (this.ws && this.ws.readyState !== 2 && this.ws.readyState !== 3) {
+      this.ws.close();
+      this.logging && this.logger.log("Websocket Connection with Shoonya API is now closed!");
+      this.emit("close");
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Shoonya
+});