DhanHQ 2.1.0

data/lib/DhanHQ/ws/orders/connection.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "eventmachine"
+require "faye/websocket"
+require "json"
+require "thread" # rubocop:disable Lint/RedundantRequireStatement
+
+module DhanHQ
+  module WS
+    module Orders
+      class Connection
+        COOL_OFF_429 = 60
+        MAX_BACKOFF  = 90
+
+        def initialize(url:, &on_json)
+          @url           = url
+          @on_json       = on_json
+          @ws            = nil
+          @stop          = false
+          @cooloff_until = nil
+        end
+
+        def start
+          Thread.new { loop_run }
+          self
+        end
+
+        def stop
+          @stop = true
+          @ws&.close
+        end
+
+        def disconnect!
+          # spec does not list a separate disconnect message; just close
+          @ws&.close
+        end
+
+        private
+
+        def loop_run
+          backoff = 2.0
+          until @stop
+            failed  = false
+            got_429 = false
+            sleep (@cooloff_until - Time.now).ceil if @cooloff_until && Time.now < @cooloff_until
+
+            begin
+              failed, got_429 = run_session
+            rescue StandardError => e
+              DhanHQ.logger&.error("[DhanHQ::WS::Orders] crashed #{e.class} #{e.message}")
+              failed = true
+            ensure
+              break if @stop
+
+              if got_429
+                @cooloff_until = Time.now + COOL_OFF_429
+                DhanHQ.logger&.warn("[DhanHQ::WS::Orders] cooling off #{COOL_OFF_429}s due to 429")
+              end
+
+              if failed
+                sleep_time = [backoff, MAX_BACKOFF].min
+                jitter = rand(0.2 * sleep_time)
+                DhanHQ.logger&.warn("[DhanHQ::WS::Orders] reconnecting in #{(sleep_time + jitter).round(1)}s")
+                sleep(sleep_time + jitter)
+                backoff *= 2.0
+              else
+                backoff = 2.0
+              end
+            end
+          end
+        end
+
+        def run_session
+          failed  = false
+          got_429 = false
+          latch   = Queue.new
+
+          runner = proc do |stopper|
+            @ws = Faye::WebSocket::Client.new(@url, nil, headers: default_headers)
+
+            @ws.on :open do |_|
+              DhanHQ.logger&.info("[DhanHQ::WS::Orders] open")
+              send_login
+            end
+
+            @ws.on :message do |ev|
+              begin
+                msg = JSON.parse(ev.data, symbolize_names: true)
+                @on_json&.call(msg)
+              rescue StandardError => e
+                DhanHQ.logger&.error("[DhanHQ::WS::Orders] bad JSON #{e.class}: #{e.message}")
+              end
+            end
+
+            @ws.on :close do |ev|
+              DhanHQ.logger&.warn("[DhanHQ::WS::Orders] close #{ev.code} #{ev.reason}")
+              failed  = (ev.code != 1000)
+              got_429 = ev.reason.to_s.include?("429")
+              latch << true
+              stopper.call
+            end
+
+            @ws.on :error do |ev|
+              DhanHQ.logger&.error("[DhanHQ::WS::Orders] error #{ev.message}")
+              failed = true
+            end
+          end
+
+          if EM.reactor_running?
+            EM.schedule { runner.call(-> {}) }
+          else
+            EM.run do
+              runner.call(-> { EM.stop })
+            end
+          end
+
+          latch.pop
+
+          [failed, got_429]
+        end
+
+        def default_headers
+          { "User-Agent" => "dhanhq-ruby/#{defined?(DhanHQ::VERSION) ? DhanHQ::VERSION : "dev"} Ruby/#{RUBY_VERSION}" }
+        end
+
+        def send_login
+          cfg = DhanHQ.configuration
+          if cfg.ws_user_type.to_s.upcase == "PARTNER"
+            payload = {
+              LoginReq: { MsgCode: 42, ClientId: cfg.partner_id },
+              UserType: "PARTNER",
+              Secret: cfg.partner_secret
+            }
+          else
+            token = cfg.access_token or raise "DhanHQ.access_token not set"
+            cid   = cfg.client_id    or raise "DhanHQ.client_id not set"
+            payload = {
+              LoginReq: { MsgCode: 42, ClientId: cid, Token: token },
+              UserType: "SELF"
+            }
+          end
+          DhanHQ.logger&.info("[DhanHQ::WS::Orders] LOGIN -> (#{payload[:UserType]})")
+          @ws.send(payload.to_json)
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/orders.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "orders/client"
+
+module DhanHQ
+  module WS
+    module Orders
+      def self.connect(&on_update)
+        Client.new.start.on(:update, &on_update)
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/packets/depth_delta_packet.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module DhanHQ
+  module WS
+    module Packets
+      # Depth delta payload (20 bytes): see Dhan spec
+      class DepthDeltaPacket < BinData::Record
+        endian :little
+        uint32 :bid_quantity        # 4
+        uint32 :ask_quantity        # 4
+        uint16 :no_of_bid_orders    # 2
+        uint16 :no_of_ask_orders    # 2
+        float  :bid_price           # 4
+        float  :ask_price           # 4
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/packets/disconnect_packet.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module DhanHQ
+  module WS
+    module Packets
+      # Disconnect payload (2 bytes). Your earlier code read signed big-endian; make it explicit.
+      class DisconnectPacket < BinData::Record
+        endian :big
+        uint16 :code
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/packets/full_packet.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# lib/dhanhq/ws/packets/full_packet.rb
+require "bindata"
+require_relative "market_depth_level"
+module DhanHQ
+  module WS
+    module Packets
+      # Binary definition of the "full" market depth packet.
+      class FullPacket < BinData::Record
+        endian :little
+
+        # Core Quote Data
+        float :ltp # 4 bytes
+        uint16 :last_trade_qty          # 2 bytes
+        uint32 :ltt                     # 4 bytes (epoch in seconds)
+        float :atp                      # 4 bytes
+        uint32 :volume                  # 4 bytes
+        int32 :total_sell_qty           # 4 bytes
+        int32 :total_buy_qty            # 4 bytes
+
+        # Open Interest & Extremes
+        int32 :open_interest            # 4 bytes
+        int32 :highest_oi               # 4 bytes (optional, F&O only)
+        int32 :lowest_oi                # 4 bytes (optional, F&O only)
+
+        # OHLC Values
+        float :day_open                 # 4 bytes
+        float :day_close                # 4 bytes
+        float :day_high                 # 4 bytes
+        float :day_low                  # 4 bytes
+
+        # Market Depth (5 levels × 20 bytes)
+        array :market_depth, initial_length: 5 do
+          market_depth_level
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/packets/header.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module DhanHQ
+  module WS
+    # Binary structures backing the streaming feed decoder.
+    module Packets
+      # Binary representation of the 8-byte frame header.
+      class Header < BinData::Record
+        endian :big # Default to big-endian for majority fields
+
+        uint8  :feed_response_code     # Byte 1
+        uint16 :message_length         # Bytes 2–3
+        uint8  :exchange_segment       # Byte 4
+
+        # Parse security_id separately using little-endian
+        # This works because `BinData` allows override
+        int32le :security_id # Bytes 5–8
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/packets/index_packet.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module WS
+    module Packets
+      # Layout not in public docs; keep raw bytes for now
+      class IndexPacket
+        attr_reader :raw
+
+        def initialize(raw) = (@raw = raw)
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/packets/market_depth_level.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# lib/dhanhq/ws/packets/market_depth_level.rb
+require "bindata"
+module DhanHQ
+  module WS
+    module Packets
+      # Binary representation of a single depth level in the feed.
+      class MarketDepthLevel < BinData::Record
+        endian :little
+
+        uint32 :bid_quantity           # 4 bytes
+        uint32 :ask_quantity           # 4 bytes
+        uint16 :no_of_bid_orders       # 2 bytes
+        uint16 :no_of_ask_orders       # 2 bytes
+        float  :bid_price              # 4 bytes
+        float  :ask_price              # 4 bytes
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/packets/market_status_packet.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module WS
+    module Packets
+      # Layout not in public docs; keep raw bytes for now
+      class MarketStatusPacket
+        attr_reader :raw
+
+        def initialize(raw) = (@raw = raw)
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/packets/oi_packet.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module DhanHQ
+  module WS
+    module Packets
+      # OI payload (4 bytes): int32 little-endian
+      class OiPacket < BinData::Record
+        endian :little
+        int32  :open_interest
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/packets/prev_close_packet.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module DhanHQ
+  module WS
+    module Packets
+      # Prev Close payload (8 bytes): float32 prev_close, int32 oi_prev (little-endian)
+      class PrevClosePacket < BinData::Record
+        endian :little
+        float :prev_close    # 4 bytes
+        int32 :oi_prev       # 4 bytes
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/packets/quote_packet.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# lib/dhanhq/ws/packets/quote_packet.rb
+require "bindata"
+module DhanHQ
+  module WS
+    module Packets
+      # Binary definition for quote snapshots emitted by the feed.
+      class QuotePacket < BinData::Record
+        endian :little
+
+        float  :ltp # 4 bytes
+        uint16 :last_trade_qty          # 2 bytes
+        uint32 :ltt                     # 4 bytes
+        float  :atp                     # 4 bytes
+        uint32 :volume                  # 4 bytes
+        int32  :total_sell_qty          # 4 bytes
+        int32  :total_buy_qty           # 4 bytes
+        float  :day_open                # 4 bytes
+        float  :day_close               # 4 bytes
+        float  :day_high                # 4 bytes
+        float  :day_low                 # 4 bytes
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/packets/ticker_packet.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module DhanHQ
+  module WS
+    module Packets
+      # Ticker payload (8 bytes): float32 ltp, int32 ltt (both little-endian)
+      class TickerPacket < BinData::Record
+        endian :little
+        float  :ltp       # 4 bytes
+        int32  :ltt       # 4 bytes
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/registry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module DhanHQ
+  module WS
+    # Tracks the set of active WebSocket clients so they can be collectively
+    # disconnected when required.
+    class Registry
+      @clients = []
+      class << self
+        # Registers a client instance with the registry.
+        #
+        # @param client [DhanHQ::WS::Client]
+        # @return [void]
+        def register(client)
+          @clients << client unless @clients.include?(client)
+        end
+
+        # Removes a client from the registry.
+        #
+        # @param client [DhanHQ::WS::Client]
+        # @return [void]
+        def unregister(client)
+          @clients.delete(client)
+        end
+
+        # Stops and removes all registered clients.
+        #
+        # @return [void]
+        def stop_all
+          @clients.dup.each do |c|
+            c.stop
+          rescue StandardError
+          end
+          @clients.clear
+        end
+      end
+    end
+
+    # convenience API
+    def self.disconnect_all_local!
+      Registry.stop_all
+    end
+  end
+end

data/lib/DhanHQ/ws/segments.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module WS
+    # Utility helpers for translating between various exchange segment
+    # representations used by the streaming API.
+    module Segments
+      # Canonical enum mapping (per Dhan spec)
+      STRING_TO_CODE = {
+        "IDX_I" => 0,
+        "NSE_EQ" => 1,
+        "NSE_FNO" => 2,
+        "NSE_CURRENCY" => 3,
+        "BSE_EQ" => 4,
+        "MCX_COMM" => 5,
+        "BSE_CURRENCY" => 7,
+        "BSE_FNO" => 8
+      }.freeze
+
+      # Lookup table converting numeric feed codes into exchange strings.
+      CODE_TO_STRING = STRING_TO_CODE.invert.freeze
+
+      # Accepts multiple segment representations and returns the canonical
+      # string used by the API.
+      #
+      # @param segment [String, Symbol, Integer]
+      # @return [String]
+      def self.to_request_string(segment)
+        case segment
+        when String
+          return segment if STRING_TO_CODE.key?(segment) # already canonical
+          return CODE_TO_STRING[segment.to_i] if /\A\d+\z/.match?(segment) # "2" -> "NSE_FNO"
+
+          STRING_TO_CODE.key(segment) || segment.upcase # e.g. "nse_fno" -> "NSE_FNO"
+        when Symbol
+          up = segment.to_s.upcase
+          STRING_TO_CODE.key(STRING_TO_CODE[up]) || up
+        when Integer
+          CODE_TO_STRING[segment] || segment.to_s
+        else
+          segment.to_s
+        end
+      end
+
+      # Normalize a single instrument for subscribe/unsubscribe requests.
+      # Ensures:
+      #   - ExchangeSegment is a STRING enum (e.g., "NSE_FNO")
+      #   - SecurityId is a STRING
+      #
+      # @param h [Hash]
+      # @return [Hash] Normalized instrument hash.
+      def self.normalize_instrument(h)
+        seg = to_request_string(h[:ExchangeSegment] || h["ExchangeSegment"])
+        sid = (h[:SecurityId] || h["SecurityId"]).to_s
+        { ExchangeSegment: seg, SecurityId: sid }
+      end
+
+      # Normalizes all instruments in the provided list.
+      #
+      # @param list [Enumerable<Hash>]
+      # @return [Array<Hash>]
+      def self.normalize_instruments(list)
+        Array(list).map { |h| normalize_instrument(h) }
+      end
+
+      # Converts a numeric response code into the API's segment string.
+      #
+      # @param code_byte [Integer]
+      # @return [String]
+      def self.from_code(code_byte)
+        CODE_TO_STRING[code_byte] || code_byte.to_s
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/singleton_lock.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+
+module DhanHQ
+  module WS
+    # File-system based lock to ensure only one WebSocket process is active per
+    # credential pair.
+    class SingletonLock
+      # @param token [String]
+      # @param client_id [String]
+      def initialize(token:, client_id:)
+        key = Digest::SHA256.hexdigest("#{client_id}:#{token}")[0, 12]
+        @path = File.expand_path("tmp/dhanhq_ws_#{key}.lock", Dir.pwd)
+        FileUtils.mkdir_p(File.dirname(@path))
+        @fh = File.open(@path, File::RDWR | File::CREAT, 0o644)
+      end
+
+      # Attempts to acquire the lock for the current process.
+      #
+      # @raise [RuntimeError] When another process already holds the lock.
+      # @return [Boolean] true when the lock is obtained.
+      def acquire!
+        unless @fh.flock(File::LOCK_NB | File::LOCK_EX)
+          pid = begin
+            @fh.read.to_i
+          rescue StandardError
+            nil
+          end
+          raise "Another DhanHQ WS process is active (pid=#{pid}). Stop it first."
+        end
+        @fh.rewind
+        @fh.truncate(0)
+        @fh.write(Process.pid.to_s)
+        @fh.flush
+        true
+      end
+
+      # Releases the lock and removes the lock file.
+      #
+      # @return [void]
+      def release!
+        @fh.flock(File::LOCK_UN)
+        @fh.close
+        begin
+          File.delete(@path)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/ws/sub_state.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module DhanHQ
+  module WS
+    # Maintains the current subscription state and performs diffing so that the
+    # client only sends incremental subscribe/unsubscribe requests.
+    class SubState
+      def initialize
+        @set   = Concurrent::Set.new
+        @mutex = Mutex.new
+      end
+
+      # Filters out instruments that are already subscribed.
+      #
+      # @param list [Array<Hash>]
+      # @return [Array<Hash>] Instruments that still need to be subscribed.
+      def want_sub(list)
+        @mutex.synchronize { list.reject { |i| @set.include?(key_for(i)) } }
+      end
+
+      # Marks the provided instruments as subscribed.
+      #
+      # @param list [Array<Hash>]
+      # @return [void]
+      def mark_subscribed!(list)
+        @mutex.synchronize { list.each { |i| @set.add(key_for(i)) } }
+      end
+
+      # Filters the instruments that are currently subscribed.
+      #
+      # @param list [Array<Hash>]
+      # @return [Array<Hash>] Instruments that can be unsubscribed.
+      def want_unsub(list)
+        @mutex.synchronize { list.select { |i| @set.include?(key_for(i)) } }
+      end
+
+      # Marks the provided instruments as unsubscribed.
+      #
+      # @param list [Array<Hash>]
+      # @return [void]
+      def mark_unsubscribed!(list)
+        @mutex.synchronize { list.each { |i| @set.delete(key_for(i)) } }
+      end
+
+      # Returns the current subscription snapshot.
+      #
+      # @return [Array<String>] Instrument identifiers in "SEGMENT:SECID" form.
+      def snapshot
+        @mutex.synchronize { @set.to_a }
+      end
+
+      private
+
+      def key_for(i) = "#{i[:ExchangeSegment]}:#{i[:SecurityId]}"
+    end
+  end
+end