DhanHQ 4.0.0 → 4.1.0

data/lib/DhanHQ/configuration.rb

@@ -15,6 +15,24 @@ module DhanHQ
     # Default Sandbox API host.
     # @return [String]
     SANDBOX_URL = Constants::Urls::SANDBOX_API_BASE
+
+    # All environments a client can run in.
+    #
+    # - +:live+ — every request hits the production host.
+    # - +:sandbox+ — every request hits the sandbox host (previous `sandbox = true` behaviour).
+    # - +:hybrid+ — market data (quotes, option chain, charts, instruments, ScanX)
+    #   hits production while trading/account requests hit the sandbox host, so a
+    #   strategy rehearses execution against real prices without risking money.
+    # @return [Array<Symbol>]
+    MODES = %i[live sandbox hybrid].freeze
+
+    # API tiers routed to the production host when {#mode} is +:hybrid+.
+    # Everything else (orders, positions, funds, statements, ...) routes to the
+    # sandbox host. Global Stocks keeps its own tier so it stays on production in
+    # hybrid mode — the sandbox host does not mirror the US-equities API.
+    # @return [Array<Symbol>]
+    HYBRID_LIVE_API_TYPES = %i[data_api quote_api option_chain global_stocks_api].freeze
+
     # The client ID for API authentication.
     # @return [String, nil] The client ID or `nil` if not set.
     attr_accessor :client_id
@@ -39,7 +57,55 @@ module DhanHQ
     attr_writer :base_url
 
     # Whether to use the sandbox environment.
-    attr_accessor :sandbox
+    #
+    # Backward-compatible facade over {#mode}: setting it to +true+ switches to
+    # full sandbox mode, +false+ back to live. Prefer {#mode} for new code — it
+    # also supports +:hybrid+ (live market data + sandbox execution).
+    #
+    # rubocop:disable Naming/PredicateMethod -- legacy attr_accessor-style API,
+    # kept as a boolean mirror of +mode+ for every caller written before :hybrid.
+    # @return [Boolean] True when every request targets the sandbox host.
+    def sandbox
+      mode == :sandbox
+    end
+    # rubocop:enable Naming/PredicateMethod
+
+    def sandbox=(value)
+      self.mode = value ? :sandbox : :live
+    end
+
+    # The environment the client runs in: +:live+, +:sandbox+, or +:hybrid+.
+    #
+    # Set via +DHAN_MODE+ or in {DhanHQ.configure}. {#sandbox=} remains as an
+    # alias for switching between +:live+ and +:sandbox+.
+    #
+    # @return [Symbol]
+    attr_reader :mode
+
+    # @param value [Symbol, String] One of {MODES} (case-insensitive).
+    # @raise [ArgumentError] When the value is not a known mode.
+    def mode=(value)
+      @mode = coerce_mode!(value)
+    end
+
+    # Per-tier environment overrides applied on top of {#mode}.
+    #
+    # Keys are API tier symbols (+:order_api+, +:data_api+, +:quote_api+,
+    # +:option_chain+, +:non_trading_api+, +:global_stocks_api+); values are
+    # +:live+ or +:sandbox+. Useful to, say, keep fund limits on production while
+    # everything else runs on the sandbox in hybrid mode:
+    #
+    #   DhanHQ.configure do |c|
+    #     c.mode = :hybrid
+    #     c.environment_overrides = { non_trading_api: :live }
+    #   end
+    #
+    # @return [Hash{Symbol => Symbol}]
+    attr_reader :environment_overrides
+
+    def environment_overrides=(value)
+      @environment_overrides = coerce_environment_overrides(value)
+    end
 
     # When true, state-changing requests (order placement, modification,
     # cancellation, position exits, trading controls) are validated and logged but
@@ -176,15 +242,54 @@ module DhanHQ
     # is nil or the default production URL, returns {SANDBOX_URL}.
     # @return [String]
     def base_url
-      if sandbox? && (@base_url.nil? || @base_url == BASE_URL)
+      base_url_for(nil)
+    end
+
+    # Returns the base URL for requests on the given API tier, honouring
+    # {#mode}, {#environment_overrides}, and an explicit {#base_url} override.
+    #
+    # In +:hybrid+ mode data tiers (see {HYBRID_LIVE_API_TYPES}) resolve to the
+    # production host while trading and account tiers resolve to the sandbox
+    # host, which is what lets a strategy read live prices while placing paper
+    # orders.
+    #
+    # @param api_type [Symbol, nil] API tier the request belongs to. +nil+ uses
+    #   the mode-level default (+:sandbox+ mode resolves to the sandbox host,
+    #   +:live+ and +:hybrid+ to production).
+    # @return [String]
+    def base_url_for(api_type)
+      if environment_for(api_type) == :sandbox && (@base_url.nil? || @base_url == BASE_URL)
         SANDBOX_URL
       else
         @base_url || BASE_URL
       end
     end
 
+    # The effective environment (+:live+ or +:sandbox+) for requests on the
+    # given API tier. Explicit {#environment_overrides} win over the {#mode}
+    # defaults.
+    #
+    # @param api_type [Symbol, nil]
+    # @return [Symbol]
+    def environment_for(api_type)
+      key = api_type&.to_sym
+      return @environment_overrides[key] if key && @environment_overrides.key?(key)
+
+      case mode
+      when :sandbox then :sandbox
+      when :hybrid then HYBRID_LIVE_API_TYPES.include?(key) ? :live : :sandbox
+      else :live
+      end
+    end
+
     def sandbox?
-      @sandbox == true
+      mode == :sandbox
+    end
+
+    # True when {#mode} is +:hybrid+ — live market data, sandbox execution.
+    # @return [Boolean]
+    def hybrid?
+      mode == :hybrid
     end
 
     # @return [Boolean] True when state-changing requests should be simulated.
@@ -228,6 +333,10 @@ module DhanHQ
                                                     default: true)
                                          end
       @base_url = attrs[:base_url] || ENV.fetch("DHAN_BASE_URL", nil)
+      @environment_overrides = coerce_environment_overrides(
+        attrs[:environment_overrides] || ENV.fetch("DHAN_ENV_OVERRIDES", nil)
+      )
+      @mode = resolve_mode(attrs)
       @ws_version = (attrs[:ws_version] || ENV.fetch("DHAN_WS_VERSION", 2)).to_i
       @ws_order_url = attrs[:ws_order_url] || ENV.fetch("DHAN_WS_ORDER_URL", nil)
       @ws_market_feed_url = attrs[:ws_market_feed_url] || ENV.fetch("DHAN_WS_MARKET_FEED_URL", nil)
@@ -242,6 +351,46 @@ module DhanHQ
 
     private
 
+    # Resolves the initial mode from attributes and ENV.
+    #
+    # Precedence: an explicit +:mode+ attribute wins, then +DHAN_MODE+, then the
+    # legacy +sandbox+ attribute / +DHAN_SANDBOX+ flag, then +:live+.
+    def resolve_mode(attrs)
+      raw_mode = attrs.key?(:mode) ? attrs[:mode] : ENV.fetch("DHAN_MODE", nil)
+      return coerce_mode!(raw_mode) if raw_mode
+
+      sandbox_flag = attrs.key?(:sandbox) ? attrs[:sandbox] : env_flag("DHAN_SANDBOX", default: false)
+      sandbox_flag ? :sandbox : :live
+    end
+
+    # Normalises a mode value, raising on anything outside {MODES}.
+    def coerce_mode!(value)
+      mode = value.to_s.strip.downcase.to_sym
+      raise ArgumentError, "unknown mode #{value.inspect}: expected one of #{MODES.join(", ")}" unless MODES.include?(mode)
+
+      mode
+    end
+
+    # Valid targets for an environment override.
+    OVERRIDE_TARGETS = %i[live sandbox].freeze
+    private_constant :OVERRIDE_TARGETS
+
+    # Normalises an environment-overrides hash: symbol keys, :live/:sandbox values.
+    def coerce_environment_overrides(value)
+      return {} if value.nil? || value == ""
+
+      value = value.split(",").to_h { |pair| pair.split("=") } if value.is_a?(String)
+      raise ArgumentError, "environment_overrides must be a Hash (tier => :live/:sandbox)" unless value.is_a?(Hash)
+
+      value.each_with_object({}) do |(tier, env), out|
+        key = tier.to_s.strip.to_sym
+        target = env.to_s.strip.downcase.to_sym
+        raise ArgumentError, "environment override for #{key} must be :live or :sandbox (got #{env.inspect})" unless OVERRIDE_TARGETS.include?(target)
+
+        out[key] = target
+      end
+    end
+
     # Reads a boolean-ish environment variable, falling back to +default+ when unset.
     def env_flag(name, default:)
       raw = ENV.fetch(name, nil)

data/lib/DhanHQ/constants.rb

@@ -130,6 +130,63 @@ module DhanHQ
     # Backward-compatible alias kept for existing SDK usage.
     Instrument = InstrumentType
 
+    # ScanX data API enums (POST /v2/data/* — company info, market movers,
+    # news headlines, technical indicators).
+    module ScanX
+      # Exchange segments accepted by POST /v2/data/companyinfo.
+      COMPANY_INFO_SEGMENTS = %w[NSE_EQ BSE_EQ].freeze
+      # Metric sections returned by POST /v2/data/companyinfo (CO = company
+      # overview, RATIOS = valuation/profitability + industry benchmarks,
+      # SHP = shareholding pattern).
+      COMPANY_INFO_METRICS = %w[CO RATIOS SHP].freeze
+      # Instrument kinds accepted by POST /v2/data/companyinfo.
+      COMPANY_INFO_INSTRUMENTS = %w[EQUITY].freeze
+
+      # Exchange segments accepted by POST /v2/data/marketmovers.
+      MARKET_MOVERS_SEGMENTS = %w[NSE_FNO BSE_FNO NSE_COMM MCX_COMM NSE_EQ BSE_EQ].freeze
+      # Instrument kinds ranked by POST /v2/data/marketmovers.
+      MARKET_MOVERS_INSTRUMENTS = %w[OPTIDX OPTSTK OPTFUT FUTIDX FUTSTK FUTCOM EQUITY].freeze
+      # Ranking categories for POST /v2/data/marketmovers.
+      MARKET_MOVERS_CATEGORIES =
+        %w[HIGHEST_OI OI_GAINERS OI_LOSERS TOP_VOLUME PRICE_GAINERS PRICE_LOSERS].freeze
+      # Equity universes accepted by POST /v2/data/marketmovers (required when
+      # instrument is EQUITY).
+      MARKET_MOVERS_UNIVERSES = %w[
+        ALL FNO_STOCKS NIFTY_50 NIFTY_BANK FINNIFTY INDIA_VIX NIFTY_MIDCAP NIFTY_NEXT_50
+        NIFTY_SMALLCAP_50 NIFTY_MID_CAP_50 NIFTY_100 NIFTY_200 NIFTY_500 NIFTY_MIDCAP_100
+        NIFTY_MIDCAP_150 NIFTY_SMALLCAP_100 NIFTY_SMALLCAP_250 NIFTY_MICROCAP_250 NIFTY_AUTO
+        NIFTY_PRIVATE_BANK NIFTY_FMCG NIFTY_ENERGY NIFTY_INFRA NIFTY_IT NIFTY_MEDIA NIFTY_METAL
+        NIFTY_MNC NIFTY_PHARMA NIFTY_PSU_BANK NIFTY_REALTY NIFTY_SERVICE_SECTOR NIFTY_CUNSUMPTION
+        GIFT_NIFTY SENSEX BSE_100 BSE_200 BSE_500 BSE_150_MIDCAP BSE_250_SMALLCAP
+        BSE_250_LARGE_MID BSE_400_MID_SMALL BSE_BANKEX BSE_AUTO BSE_CAPITAL_GOODS
+        BSE_CONSUMER_DURABLES BSE_ENERGY BSE_FINANCE BSE_FMCG BSE_HEALTHCARE BSE_INDIA_MFG
+        BSE_INDUSTRIALS BSE_IPO BSE_IT BSE_METALS BSE_OIL_AND_GAS BSE_POWER BSE_PSU BSE_TELECOM
+      ].freeze
+
+      # News categories accepted by POST /v2/data/newsheadline.
+      NEWS_CATEGORIES = %w[
+        ALL COMPANIES EQUITY_MARKETS DEBT_MARKETS IPO GLOBAL INDIAN_ECONOMY GLOBAL_ECONOMY
+        CURRENCY COMMODITIES CRYPTOCURRENCIES GOVERNMENT_POLICY_AND_REGULATION INFRASTRUCTURE
+        INTERNATIONAL_TRADE INVESTMENT_IDEAS REAL_ESTATE STARTUPS TECHNOLOGY MUTUAL_FUNDS
+      ].freeze
+      # News scoping options (portfolio/watchlist) for POST /v2/data/newsheadline.
+      NEWS_UNIVERSES = %w[PORTFOLIO WATCHLIST].freeze
+
+      # Exchange segments accepted by POST /v2/data/technical.
+      TECHNICAL_SEGMENTS = %w[NSE_EQ IDX_I].freeze
+      # Instrument kinds accepted by POST /v2/data/technical.
+      TECHNICAL_INSTRUMENTS = %w[INDEX EQUITY].freeze
+      # Candle timeframes for POST /v2/data/technical (1/5/15 minute, D = daily).
+      TECHNICAL_TIMEFRAMES = %w[1 5 15 D].freeze
+      # Indicator identifiers computed by POST /v2/data/technical.
+      TECHNICAL_INDICATORS = %w[
+        SMA_5 SMA_10 SMA_20 SMA_50 SMA_100 SMA_200
+        EMA_5 EMA_10 EMA_20 EMA_50 EMA_100 EMA_200
+        RSI_14 MACD_HIST STOCH STOCHRSI_14 ATR_14 ADX_14 UO ROC WILLR
+        PIVOT_CLASSIC PIVOT_FIBONACCI PIVOT_CAMARILLA
+      ].freeze
+    end
+
     # Minute intervals allowed by POST /v2/charts/intraday (charts annexure).
     module ChartInterval
       ONE = "1"
@@ -536,7 +593,8 @@ module DhanHQ
       "/v2/marketfeed/",
       "/v2/optionchain",
       "/v2/instrument/",
-      "/v2/charts"
+      "/v2/charts",
+      "/v2/data"
     ].freeze
 
     # Path prefixes for which the request body (POST/PUT/PATCH) must include dhanClientId.
@@ -555,6 +613,7 @@ module DhanHQ
       /v2/killswitch
       /v2/ip
       /v2/globalstocks
+      /v2/data/newsheadline
     ].freeze
 
     # Path prefixes whose non-GET requests change real account state — they place,

data/lib/DhanHQ/contracts/company_info_contract.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates request for POST /v2/data/companyinfo (ScanX company fundamentals).
+    #
+    # securityId (digits), exchangeSegment (NSE_EQ/BSE_EQ), instrument (EQUITY),
+    # metrics (one or more of CO / RATIOS / SHP).
+    class CompanyInfoContract < BaseContract
+      params do
+        required(:security_id).filled(:string)
+        required(:exchange_segment).filled(:string, included_in?: Constants::ScanX::COMPANY_INFO_SEGMENTS)
+        required(:instrument).filled(:string, included_in?: Constants::ScanX::COMPANY_INFO_INSTRUMENTS)
+        required(:metrics).filled(:array, min_size?: 1) do
+          each(:str?, included_in?: Constants::ScanX::COMPANY_INFO_METRICS)
+        end
+      end
+
+      rule(:security_id) do
+        key.failure("must be a numeric security id string") unless value.to_s.match?(/\A\d+\z/)
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/market_movers_contract.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "date"
+
+module DhanHQ
+  module Contracts
+    # Validates request for POST /v2/data/marketmovers (ScanX ranked instruments).
+    #
+    # exchangeSegment, instrument[] (options / futures / equity kinds, no mixing
+    # groups), category, limit (1-100). Expiry is required for options/futures;
+    # universe is required for EQUITY and ignored otherwise.
+    class MarketMoversContract < BaseContract
+      DERIVATIVE_INSTRUMENTS = %w[OPTIDX OPTSTK OPTFUT FUTIDX FUTSTK FUTCOM].freeze
+      private_constant :DERIVATIVE_INSTRUMENTS
+
+      params do
+        required(:exchange_segment).filled(:string, included_in?: Constants::ScanX::MARKET_MOVERS_SEGMENTS)
+        required(:instrument).filled(:array, min_size?: 1) do
+          each(:str?, included_in?: Constants::ScanX::MARKET_MOVERS_INSTRUMENTS)
+        end
+        required(:category).filled(:string, included_in?: Constants::ScanX::MARKET_MOVERS_CATEGORIES)
+        required(:limit).filled(:integer, included_in?: 1..100)
+        optional(:expiry).filled(:string)
+        optional(:universe).filled(:string, included_in?: Constants::ScanX::MARKET_MOVERS_UNIVERSES)
+      end
+
+      rule(:expiry) do
+        next unless value.is_a?(String)
+
+        unless value.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+          key.failure("must be in YYYY-MM-DD format")
+          next
+        end
+
+        Date.parse(value)
+      rescue StandardError
+        key.failure("must be a valid date")
+      end
+
+      # Expiry is required when ranking derivatives; universe is required for EQUITY.
+      rule(:instrument, :expiry) do
+        instruments = Array(values[:instrument]).map(&:to_s)
+        key(:expiry).failure("is required when instrument includes options or futures") if derivative?(instruments) && values[:expiry].to_s.empty?
+      end
+
+      rule(:instrument, :universe) do
+        instruments = Array(values[:instrument]).map(&:to_s)
+        key(:universe).failure("is required when instrument is EQUITY") if instruments.include?(Constants::InstrumentType::EQUITY) && values[:universe].to_s.empty?
+      end
+
+      # True when any requested instrument is an option or future.
+      def derivative?(instruments)
+        instruments.any? { |i| DERIVATIVE_INSTRUMENTS.include?(i) }
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/news_headline_contract.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates request for POST /v2/data/newsheadline (ScanX live news).
+    #
+    # categories[] (ALL or any news category), limit (1-50), optional universe
+    # (PORTFOLIO / WATCHLIST) and stock_list[] of security ids. dhanClientId is
+    # injected by the client layer and is not validated here.
+    class NewsHeadlineContract < BaseContract
+      params do
+        required(:categories).filled(:array, min_size?: 1) do
+          each(:str?, included_in?: Constants::ScanX::NEWS_CATEGORIES)
+        end
+        required(:limit).filled(:integer, included_in?: 1..50)
+        optional(:universe).filled(:string, included_in?: Constants::ScanX::NEWS_UNIVERSES)
+        optional(:stock_list).filled(:array) { each(:str?) }
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/technical_data_contract.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates request for POST /v2/data/technical (ScanX technical indicators).
+    #
+    # securityId (digits), exchangeSegment (NSE_EQ/IDX_I), instrument
+    # (INDEX/EQUITY), timeframe (1/5/15/D), indicators[] (e.g. SMA_20, RSI_14).
+    class TechnicalDataContract < BaseContract
+      params do
+        required(:security_id).filled(:string)
+        required(:exchange_segment).filled(:string, included_in?: Constants::ScanX::TECHNICAL_SEGMENTS)
+        required(:instrument).filled(:string, included_in?: Constants::ScanX::TECHNICAL_INSTRUMENTS)
+        required(:timeframe).filled(:string, included_in?: Constants::ScanX::TECHNICAL_TIMEFRAMES)
+        required(:indicators).filled(:array, min_size?: 1) do
+          each(:str?, included_in?: Constants::ScanX::TECHNICAL_INDICATORS)
+        end
+      end
+
+      rule(:security_id) do
+        key.failure("must be a numeric security id string") unless value.to_s.match?(/\A\d+\z/)
+      end
+    end
+  end
+end

data/lib/DhanHQ/core/base_api.rb

@@ -64,21 +64,6 @@ module DhanHQ
 
     private
 
-    # Performs an API request.
-    #
-    # @param method [Symbol] HTTP method (:get, :post, :put, :delete)
-    # @param endpoint [String] API endpoint
-    # @param params [Hash] Request parameters
-    # @return [Hash, Array] The parsed API response
-    # @raise [DhanHQ::Error] If an API error occurs.
-    def request(method, endpoint, params: {})
-      formatted_params = format_params(endpoint, params)
-
-      response = client.request(method, build_path(endpoint), formatted_params)
-
-      handle_response(response)
-    end
-
     # Construct the complete API URL
     #
     # @param endpoint [String] API endpoint

data/lib/DhanHQ/core/base_model.rb

@@ -40,14 +40,31 @@ module DhanHQ
     class << self
       attr_reader :defined_attributes
 
-      # Registers the set of attributes for this model
+      # Registers the set of attributes for this model. Also defines the
+      # snake_case and camelCase readers once per class, so instances stop
+      # allocating per-record singleton methods.
       #
       # @param args [Array<Symbol, String>] A list of attribute names
       def attributes(*args)
         @defined_attributes ||= []
-        @defined_attributes.concat(args.map(&:to_s))
+        new_attrs = args.map(&:to_s)
+        @defined_attributes.concat(new_attrs)
+        define_accessors(new_attrs)
+        @defined_attributes
       end
 
+      # Defines one snake_case and one camelCase reader per attribute, reading
+      # through @attributes so every instance stays in sync. Called from
+      # {attributes}; private because it is a declaration helper.
+      def define_accessors(attrs)
+        attrs.each do |attr|
+          camel = attr.to_s.camelize(:lower)
+          define_method(attr) { @attributes[attr] }
+          define_method(camel) { @attributes[attr] }
+        end
+      end
+      private :define_accessors
+
       # Provide a default API type, can be overridden by child classes
       #
       # e.g., def self.api_type; :data_api; end
@@ -64,6 +81,13 @@ module DhanHQ
         @api ||= BaseAPI.new(api_type: api_type)
       end
 
+      # Parameter key style used by {#to_request_params}: :camel (camelCase)
+      # by default. Models whose API takes TitleCase keys (the option chain)
+      # override this to :title.
+      def param_key_style
+        :camel
+      end
+
       ##
       # Returns the API resource used by collection methods.
       #
@@ -91,6 +115,8 @@ module DhanHQ
       # Validate attributes before creating a new instance
       def validate_attributes(attributes)
         contract = validation_contract
+        return true if contract.nil?
+
         result = contract.call(attributes)
 
         raise ArgumentError, "Validation failed: #{result.errors.to_h}" if result.failure?
@@ -132,8 +158,6 @@ module DhanHQ
       # @param attributes [Hash] The attributes of the resource
       # @return [DhanHQ::BaseModel, DhanHQ::ErrorObject] The resource or error object
       def create(attributes)
-        # validate_params!(attributes, validation_contract)
-
         response = resource.post("", params: attributes)
         build_from_response(response)
       end
@@ -242,7 +266,7 @@ module DhanHQ
       if self.class.defined_attributes&.include?("dhan_client_id") && !attrs[:dhan_client_id] && DhanHQ.configuration.client_id
         attrs[:dhan_client_id] = DhanHQ.configuration.client_id
       end
-      optionchain_api? ? titleize_keys(attrs) : camelize_keys(attrs)
+      self.class.param_key_style == :title ? titleize_keys(attrs) : camelize_keys(attrs)
     end
 
     # Identifier inferred from the loaded attributes.
@@ -254,19 +278,15 @@ module DhanHQ
       id_value&.to_s
     end
 
-    # Dynamically assign attributes as methods
+    # Assigns each declared attribute to an instance variable. The accessor
+    # methods themselves are defined once per class (see .attributes); the
+    # ivars exist for {AttributeHelper#inspect} and debugging.
     def assign_attributes
       self.class.defined_attributes&.each do |attr|
         instance_variable_set(:"@#{attr}", @attributes[attr])
-        define_singleton_method(attr) { instance_variable_get(:"@#{attr}") }
-        define_singleton_method(attr.to_s.camelize(:lower)) { instance_variable_get(:"@#{attr}") }
       end
     end
 
-    def optionchain_api?
-      self.class.name.include?("OptionChain")
-    end
-
     # Validate attributes using contract
     def valid?
       contract_class = validation_contract || self.class.validation_contract

data/lib/DhanHQ/helpers/attribute_helper.rb

@@ -69,27 +69,5 @@ module DhanHQ
       instance_vars = self.class.defined_attributes.map { |attr| "#{attr}: #{instance_variable_get(:"@#{attr}")}" }
       "#<#{self.class.name} #{instance_vars.join(", ")}>"
     end
-
-    # def format_params(path, params)
-    #   return params unless params.is_a?(Hash)
-
-    #   if optionchain_api?(path)
-    #     titleize_keys(params)
-    #   else
-    #     camelize_keys(params)
-    #   end
-    # end
-
-    # def camelize_keys(hash)
-    #   hash.transform_keys { |key| key.to_s.camelize(:lower) }
-    # end
-
-    # def titleize_keys(hash)
-    #   hash.transform_keys { |key| key.to_s.titleize.delete(" ") }
-    # end
-
-    # def optionchain_api?(path)
-    #   path.include?("/optionchain")
-    # end
   end
 end

data/lib/DhanHQ/models/option_chain.rb

@@ -55,6 +55,13 @@ module DhanHQ
       end
 
       class << self
+        ##
+        # The option chain API takes TitleCase keys (e.g. "UnderlyingScripValue");
+        # see BaseModel.param_key_style.
+        def param_key_style
+          :title
+        end
+
         ##
         # Provides a shared instance of the OptionChain resource.
         #

data/lib/DhanHQ/models/order.rb

@@ -491,12 +491,12 @@ module DhanHQ
       #   order = DhanHQ::Models::Order.find("112111182045")
       #   order.modify(validity: "IOC")
       #
-      # @raise [RuntimeError] If order ID is missing
+      # @raise [DhanHQ::OrderError] If order ID is missing
       # @raise [DhanHQ::ValidationError] If validation fails for any parameter
       # @raise [DhanHQ::ModificationLimitError] If this instance has already been modified 25 times (Dhan API cap)
       # @note Count is per Order instance in this process; a fresh find() resets it.
       def modify(new_params)
-        raise "Order ID is required to modify an order" unless id
+        raise DhanHQ::OrderError, "Order ID is required to modify an order" unless id
 
         count = @modification_count || 0
         if count >= Constants::RateLimit::ORDER_MODIFICATIONS_PER_ORDER
@@ -537,9 +537,9 @@ module DhanHQ
       #     puts "Failed to cancel order"
       #   end
       #
-      # @raise [RuntimeError] If order ID is missing
+      # @raise [DhanHQ::OrderError] If order ID is missing
       def cancel
-        raise "Order ID is required to cancel an order" unless id
+        raise DhanHQ::OrderError, "Order ID is required to cancel an order" unless id
 
         DhanHQ.logger&.info("[DhanHQ::Models::Order] Cancelling order #{id}")
         response = self.class.resource.cancel(id)
@@ -566,9 +566,9 @@ module DhanHQ
       #   puts "Updated status: #{order.order_status}"
       #   puts "Filled: #{order.filled_qty}/#{order.quantity}"
       #
-      # @raise [RuntimeError] If order ID is missing
+      # @raise [DhanHQ::OrderError] If order ID is missing
       def refresh
-        raise "Order ID is required to refresh an order" unless id
+        raise DhanHQ::OrderError, "Order ID is required to refresh an order" unless id
 
         self.class.find(id)
       end
@@ -603,7 +603,7 @@ module DhanHQ
       alias delete destroy
 
       def slice_order(params)
-        raise "Order ID is required to slice an order" unless id
+        raise DhanHQ::OrderError, "Order ID is required to slice an order" unless id
 
         normalized = snake_case(params)
         normalized[:dhan_client_id] ||= DhanHQ.configuration&.client_id