DhanHQ 2.6.1 → 2.6.3

data/lib/DhanHQ/configuration.rb

@@ -9,9 +9,12 @@ module DhanHQ
   # @see https://dhanhq.co/docs/v2/ DhanHQ API Documentation
   class Configuration
     # Default REST API host used when the base URL is not overridden.
-    #
     # @return [String]
-    BASE_URL = "https://api.dhan.co/v2"
+    BASE_URL = Constants::Urls::REST_API_BASE
+
+    # Default Sandbox API host.
+    # @return [String]
+    SANDBOX_URL = Constants::Urls::SANDBOX_API_BASE
     # The client ID for API authentication.
     # @return [String, nil] The client ID or `nil` if not set.
     attr_accessor :client_id
@@ -32,8 +35,11 @@ module DhanHQ
     attr_accessor :on_token_expired
 
     # The base URL for API requests.
-    # @return [String] The base URL for the DhanHQ API.
-    attr_accessor :base_url
+    # @return [String]
+    attr_writer :base_url
+
+    # Whether to use the sandbox environment.
+    attr_accessor :sandbox
 
     # URL for the compact CSV format of instruments.
     # @return [String] URL for compact CSV.
@@ -48,21 +54,33 @@ module DhanHQ
     attr_accessor :ws_version
 
     # Websocket order updates endpoint.
+    # Sandbox does not support WebSocket; always returns production URL unless overridden.
     # @return [String]
-    attr_accessor :ws_order_url
+    def ws_order_url
+      @ws_order_url || Constants::Urls::WS_ORDER_UPDATE
+    end
 
     # Websocket market feed endpoint.
+    # Sandbox does not support WebSocket; always returns production URL unless overridden.
     # @return [String]
-    attr_accessor :ws_market_feed_url
+    def ws_market_feed_url
+      @ws_market_feed_url || Constants::Urls::WS_MARKET_FEED
+    end
 
     # Websocket market depth endpoint.
+    # Sandbox does not support WebSocket; always returns production URL unless overridden.
     # @return [String]
-    attr_accessor :ws_market_depth_url
+    def ws_market_depth_url
+      @ws_market_depth_url || Constants::Urls::WS_DEPTH_20
+    end
 
     # Market depth level (20 or 200).
     # @return [Integer]
     attr_accessor :market_depth_level
 
+    # Setters for websocket URLs
+    attr_writer :ws_order_url, :ws_market_feed_url, :ws_market_depth_url
+
     # Websocket user type for order updates.
     # @return [String] "SELF" or "PARTNER".
     attr_accessor :ws_user_type
@@ -91,6 +109,21 @@ module DhanHQ
       end
     end
 
+    # Returns the base URL to use. If {#sandbox} is true and {#base_url}
+    # is nil or the default production URL, returns {SANDBOX_URL}.
+    # @return [String]
+    def base_url
+      if sandbox? && (@base_url.nil? || @base_url == BASE_URL)
+        SANDBOX_URL
+      else
+        @base_url || BASE_URL
+      end
+    end
+
+    def sandbox?
+      @sandbox == true
+    end
+
     # Initializes a new configuration instance with default values.
     #
     # @example
@@ -100,11 +133,12 @@ module DhanHQ
     def initialize
       @client_id = ENV.fetch("DHAN_CLIENT_ID", nil)
       @access_token = ENV.fetch("DHAN_ACCESS_TOKEN", nil)
-      @base_url       = ENV.fetch("DHAN_BASE_URL", "https://api.dhan.co/v2")
+      @sandbox        = ENV.fetch("DHAN_SANDBOX", "false").to_s.casecmp("true").zero?
+      @base_url       = ENV.fetch("DHAN_BASE_URL", nil)
       @ws_version     = ENV.fetch("DHAN_WS_VERSION", 2).to_i
-      @ws_order_url = ENV.fetch("DHAN_WS_ORDER_URL", "wss://api-order-update.dhan.co")
-      @ws_market_feed_url = ENV.fetch("DHAN_WS_MARKET_FEED_URL", "wss://api-feed.dhan.co")
-      @ws_market_depth_url = ENV.fetch("DHAN_WS_MARKET_DEPTH_URL", "wss://depth-api-feed.dhan.co/twentydepth")
+      @ws_order_url = ENV.fetch("DHAN_WS_ORDER_URL", nil)
+      @ws_market_feed_url = ENV.fetch("DHAN_WS_MARKET_FEED_URL", nil)
+      @ws_market_depth_url = ENV.fetch("DHAN_WS_MARKET_DEPTH_URL", nil)
       @market_depth_level = ENV.fetch("DHAN_MARKET_DEPTH_LEVEL", "20").to_i
       @ws_user_type   = ENV.fetch("DHAN_WS_USER_TYPE", "SELF")
       @partner_id     = ENV.fetch("DHAN_PARTNER_ID", nil)

data/lib/DhanHQ/constants.rb

@@ -18,6 +18,14 @@ module DhanHQ
       BSE_FNO = "BSE_FNO"
 
       ALL = [IDX_I, NSE_EQ, NSE_FNO, NSE_CURRENCY, NSE_COMM, BSE_EQ, MCX_COMM, BSE_CURRENCY, BSE_FNO].freeze
+      # Segments allowed by POST /v2/margincalculator (single and multi).
+      MARGIN_CALC_ALL = [NSE_EQ, NSE_FNO, BSE_EQ, BSE_FNO, MCX_COMM].freeze
+      # Segments allowed by POST /v2/forever/orders (create).
+      FOREVER_ORDER_ALL = [NSE_EQ, NSE_FNO, BSE_EQ, BSE_FNO, MCX_COMM].freeze
+      # Segments for conditional trigger (equities and indices only). POST/PUT /v2/alerts/orders.
+      ALERT_CONDITION_ALL = [NSE_EQ, BSE_EQ, IDX_I].freeze
+      # Segments allowed by POST /v2/charts/historical and POST /v2/charts/intraday (excludes NSE_COMM).
+      CHART_ALL = [IDX_I, NSE_EQ, NSE_FNO, NSE_CURRENCY, BSE_EQ, BSE_FNO, BSE_CURRENCY, MCX_COMM].freeze
     end
 
     # Product types for order placement.
@@ -30,6 +38,10 @@ module DhanHQ
       BO = "BO"
 
       ALL = [CNC, INTRADAY, MARGIN, MTF, CO, BO].freeze
+      # Product types allowed by POST /v2/margincalculator (single and multi).
+      MARGIN_CALC_ALL = [CNC, INTRADAY, MARGIN, MTF].freeze
+      # Product types allowed by POST /v2/forever/orders (create). Only CNC and MTF.
+      FOREVER_ORDER_ALL = [CNC, MTF].freeze
     end
 
     # Buy/Sell transaction types.
@@ -112,6 +124,17 @@ module DhanHQ
     # Backward-compatible alias kept for existing SDK usage.
     Instrument = InstrumentType
 
+    # Minute intervals allowed by POST /v2/charts/intraday (charts annexure).
+    module ChartInterval
+      ONE = "1"
+      FIVE = "5"
+      FIFTEEN = "15"
+      TWENTY_FIVE = "25"
+      SIXTY = "60"
+
+      ALL = [ONE, FIVE, FIFTEEN, TWENTY_FIVE, SIXTY].freeze
+    end
+
     # Option types for derivatives trading.
     module OptionType
       CALL = "CALL"
@@ -365,10 +388,33 @@ module DhanHQ
       ORDER_MODIFICATIONS_PER_ORDER = 25
     end
 
+    # Canonical Dhan API, auth, WebSocket and instrument URLs (see https://dhanhq.co/docs/v2/).
+    # Configuration and Auth use these as defaults; ENV overrides apply at runtime.
+    module Urls
+      REST_API_BASE = "https://api.dhan.co/v2"
+      SANDBOX_API_BASE = "https://sandbox.dhan.co/v2"
+      AUTH_BASE = "https://auth.dhan.co"
+      WS_MARKET_FEED = "wss://api-feed.dhan.co"
+      WS_ORDER_UPDATE = "wss://api-order-update.dhan.co"
+      WS_DEPTH_20 = "wss://depth-api-feed.dhan.co/twentydepth"
+      WS_DEPTH_200 = "wss://full-depth-api.dhan.co/twohundreddepth"
+      INSTRUMENT_CSV_COMPACT = "https://images.dhan.co/api-data/api-scrip-master.csv"
+      INSTRUMENT_CSV_DETAILED = "https://images.dhan.co/api-data/api-scrip-master-detailed.csv"
+      DOCS = "https://dhanhq.co/docs/v2"
+      # Origin header value for WebSocket connections (Dhan main site).
+      ORIGIN = "https://dhanhq.co"
+    end
+
     # Backward-compatible arrays used across existing validations.
     TRANSACTION_TYPES = TransactionType::ALL
     EXCHANGE_SEGMENTS = ExchangeSegment::ALL
+    CHART_EXCHANGE_SEGMENTS = ExchangeSegment::CHART_ALL
     INSTRUMENTS = InstrumentType::ALL
+    CHART_INTERVALS = ChartInterval::ALL
+    MARGIN_CALCULATOR_SEGMENTS = ExchangeSegment::MARGIN_CALC_ALL
+    MARGIN_PRODUCT_TYPES = ProductType::MARGIN_CALC_ALL
+    FOREVER_ORDER_SEGMENTS = ExchangeSegment::FOREVER_ORDER_ALL
+    FOREVER_ORDER_PRODUCT_TYPES = ProductType::FOREVER_ORDER_ALL
     PRODUCT_TYPES = ProductType::ALL
     ORDER_TYPES = OrderType::ALL
     VALIDITY_TYPES = Validity::ALL
@@ -376,6 +422,8 @@ module DhanHQ
     ORDER_STATUSES = OrderStatus::ALL
     COMPARISON_TYPES = ComparisonType::ALL
     OPERATORS = Operator::ALL
+    ALERT_CONDITION_SEGMENTS = ExchangeSegment::ALERT_CONDITION_ALL
+    ALERT_TIMEFRAMES = %w[DATE ONE_MIN FIVE_MIN FIFTEEN_MIN DAY].freeze
 
     # Exchange aliases used when building subscription payloads.
     NSE = ExchangeSegment::NSE_EQ
@@ -387,7 +435,8 @@ module DhanHQ
     BSE_FNO = ExchangeSegment::BSE_FNO
     INDEX = ExchangeSegment::IDX_I
 
-    OPTION_SEGMENTS = [NSE, BSE, CUR, MCX, FNO, NSE_FNO, BSE_FNO, INDEX].freeze
+    # Underlying segments accepted by POST /v2/optionchain and POST /v2/optionchain/expirylist.
+    OPTION_CHAIN_UNDERLYING_SEGMENTS = %w[IDX_I NSE_FNO BSE_FNO MCX_FO].freeze
 
     # Canonical labels kept for compatibility with previous SDK versions.
     BUY = TransactionType::BUY
@@ -409,15 +458,30 @@ module DhanHQ
     IOC = Validity::IOC
 
     # Download URL for the compact instrument master CSV.
-    COMPACT_CSV_URL = "https://images.dhan.co/api-data/api-scrip-master.csv"
+    COMPACT_CSV_URL = Urls::INSTRUMENT_CSV_COMPACT
     # Download URL for the detailed instrument master CSV.
-    DETAILED_CSV_URL = "https://images.dhan.co/api-data/api-scrip-master-detailed.csv"
+    DETAILED_CSV_URL = Urls::INSTRUMENT_CSV_DETAILED
 
     # API route prefixes that require a `client-id` header in addition to the access token.
     DATA_API_PREFIXES = [
       "/v2/marketfeed/",
       "/v2/optionchain",
-      "/v2/instrument/"
+      "/v2/instrument/",
+      "/v2/charts"
+    ].freeze
+
+    # Path prefixes for which the request body (POST/PUT/PATCH) must include dhanClientId.
+    # Injection is done in the client layer when building the payload.
+    PAYLOAD_REQUIRES_DHAN_CLIENT_ID_PREFIXES = %w[
+      /alerts/orders
+      /v2/orders
+      /v2/forever
+      /v2/super/orders
+      /v2/positions
+      /v2/pnlExit
+      /v2/margincalculator
+      /v2/killswitch
+      /v2/ip
     ].freeze
 
     # Mapping of exchange and segment combinations to canonical exchange segment names.

data/lib/DhanHQ/contracts/alert_order_contract.rb

@@ -2,45 +2,52 @@
 
 module DhanHQ
   module Contracts
-    # Validates alert order payloads for create/update per dhanhq.co/docs/v2/conditional-trigger/
-    # Condition requires exchange_segment, exp_date, frequency; time_frame required for TECHNICAL_* comparison types.
+    # Validates Conditional Trigger (alert order) payloads for POST /v2/alerts/orders and PUT /v2/alerts/orders/{alertId}.
+    # Condition: exchangeSegment (NSE_EQ|BSE_EQ|IDX_I), timeframe (required), comparisonType, operator, expDate, frequency;
+    #   indicatorName/time_frame required for TECHNICAL_* comparison types.
+    # Orders: transactionType, exchangeSegment, productType (CNC|INTRADAY|MARGIN|MTF), orderType, securityId,
+    #   quantity, validity, price (required); discQuantity, triggerPrice optional.
     class AlertOrderContract < BaseContract
       params do
         required(:condition).hash do
           required(:security_id).filled(:string, max_size?: 20)
-          required(:exchange_segment).filled(:string, included_in?: EXCHANGE_SEGMENTS)
+          required(:exchange_segment).filled(:string, included_in?: ALERT_CONDITION_SEGMENTS)
           required(:comparison_type).filled(:string, included_in?: COMPARISON_TYPES)
-          optional(:indicator_name).maybe(:string)
-          optional(:time_frame).maybe(:string)
+          required(:time_frame).filled(:string, included_in?: ALERT_TIMEFRAMES)
           required(:operator).filled(:string, included_in?: OPERATORS)
+          required(:exp_date).filled(:string, format?: /\A\d{4}-\d{2}-\d{2}\z/)
+          required(:frequency).filled(:string)
+          optional(:indicator_name).maybe(:string)
           optional(:comparing_value).maybe(:float)
           optional(:comparing_indicator_name).maybe(:string)
-          required(:exp_date).filled(:string)
-          required(:frequency).filled(:string)
+          optional(:user_note).maybe(:string)
         end
         required(:orders).array(:hash) do
           required(:transaction_type).filled(:string, included_in?: TRANSACTION_TYPES)
           required(:exchange_segment).filled(:string, included_in?: EXCHANGE_SEGMENTS)
-          required(:product_type).filled(:string, included_in?: PRODUCT_TYPES)
+          required(:product_type).filled(:string, included_in?: MARGIN_PRODUCT_TYPES)
           required(:order_type).filled(:string, included_in?: ORDER_TYPES)
           required(:security_id).filled(:string, max_size?: 20)
           required(:quantity).filled(:integer, gt?: 0)
           required(:validity).filled(:string, included_in?: VALIDITY_TYPES)
-          optional(:price).maybe(:float)
-          optional(:trigger_price).maybe(:float)
+          required(:price).filled # string or number; API expects string, coerce in serialization
+          optional(:disc_quantity).maybe(:string)
+          optional(:trigger_price).maybe(:string)
         end
       end
 
       rule(condition: :indicator_name) do
-        if values[:condition] && values[:condition][:comparison_type].to_s.start_with?("TECHNICAL") && !value
-          key(condition: :indicator_name).failure("is required for technical comparisons")
-        end
+        next unless values.dig(:condition, :comparison_type).to_s.start_with?("TECHNICAL")
+        next if value && !value.to_s.strip.empty?
+
+        key(%i[condition indicator_name]).failure("is required for technical comparisons")
       end
 
       rule(condition: :time_frame) do
-        if values[:condition] && values[:condition][:comparison_type].to_s.start_with?("TECHNICAL") && !value
-          key(condition: :time_frame).failure("is required for technical comparisons")
-        end
+        next unless values.dig(:condition, :comparison_type).to_s.start_with?("TECHNICAL")
+        next if value && !value.to_s.strip.empty?
+
+        key(%i[condition time_frame]).failure("is required for technical comparisons")
       end
     end
   end

data/lib/DhanHQ/contracts/expired_options_data_contract.rb

@@ -23,7 +23,9 @@ module DhanHQ
       end
 
       rule(:exchange_segment) do
-        valid_segments = %w[NSE_FNO BSE_FNO NSE_EQ BSE_EQ]
+        # IDX_I for index options, NSE_EQ/BSE_EQ for equity options,
+        # plus NSE_FNO/BSE_FNO for derivatives.
+        valid_segments = %w[IDX_I NSE_EQ BSE_EQ NSE_FNO BSE_FNO]
         key.failure("must be one of: #{valid_segments.join(", ")}") unless valid_segments.include?(value)
       end
 
@@ -43,7 +45,7 @@ module DhanHQ
       end
 
       rule(:strike) do
-        unless value.match?(/\AATM(\+|-)?\d*\z/) || value == "ATM"
+        unless value.match?(/\AATM(\+|-)?\d+\z/) || value == "ATM"
           key.failure("must be in format ATM, ATM+1, ATM-1, etc. " \
                       "(up to ATM+10/ATM-10 for Index Options, ATM+3/ATM-3 for others)")
         end

data/lib/DhanHQ/contracts/forever_order_contract.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates request for POST /v2/forever/orders (create Forever / GTT order).
+    # orderFlag: SINGLE | OCO. productType: CNC | MTF. For OCO, price1, triggerPrice1, quantity1 required.
+    class ForeverOrderCreateContract < BaseContract
+      params do
+        required(:dhan_client_id).filled(:string)
+        required(:order_flag).filled(:string, included_in?: OrderFlag::ALL)
+        required(:transaction_type).filled(:string, included_in?: TRANSACTION_TYPES)
+        required(:exchange_segment).filled(:string, included_in?: FOREVER_ORDER_SEGMENTS)
+        required(:product_type).filled(:string, included_in?: FOREVER_ORDER_PRODUCT_TYPES)
+        required(:order_type).filled(:string, included_in?: %w[LIMIT MARKET])
+        required(:validity).filled(:string, included_in?: VALIDITY_TYPES)
+        required(:security_id).filled(:string)
+        required(:quantity).filled(:integer, gt?: 0)
+        required(:price).filled(:float, gt?: 0)
+        required(:trigger_price).filled(:float)
+        optional(:correlation_id).maybe(:string, max_size?: 30, format?: /\A[a-zA-Z0-9 _-]*\z/)
+        optional(:disclosed_quantity).maybe(:integer, gteq?: 0)
+        optional(:price1).maybe(:float, gt?: 0)
+        optional(:trigger_price1).maybe(:float)
+        optional(:quantity1).maybe(:integer, gt?: 0)
+      end
+
+      rule(:order_flag) do
+        next unless value == DhanHQ::Constants::OrderFlag::OCO
+
+        missing = []
+        missing << "price1" if values[:price1].nil? || values[:price1].to_f <= 0
+        missing << "trigger_price1" if values[:trigger_price1].nil?
+        missing << "quantity1" if values[:quantity1].nil? || values[:quantity1].to_i < 1
+        key.failure("required for OCO: #{missing.join(", ")}") if missing.any?
+      end
+    end
+
+    # Validates request for PUT /v2/forever/orders/{order-id} (modify Forever order).
+    # orderType: LIMIT | MARKET | STOP_LOSS | STOP_LOSS_MARKET. legName: TARGET_LEG | STOP_LOSS_LEG.
+    class ForeverOrderModifyContract < BaseContract
+      params do
+        required(:dhan_client_id).filled(:string)
+        required(:order_id).filled(:string)
+        required(:order_flag).filled(:string, included_in?: OrderFlag::ALL)
+        required(:order_type).filled(:string, included_in?: ORDER_TYPES)
+        required(:leg_name).filled(:string, included_in?: %w[TARGET_LEG STOP_LOSS_LEG])
+        required(:quantity).filled(:integer, gt?: 0)
+        required(:price).filled(:float, gt?: 0)
+        required(:trigger_price).filled(:float)
+        required(:validity).filled(:string, included_in?: VALIDITY_TYPES)
+        optional(:disclosed_quantity).maybe(:integer, gteq?: 0)
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/historical_data_contract.rb

@@ -4,40 +4,38 @@ require "date"
 
 module DhanHQ
   module Contracts
-    # Validates payloads for the historical data endpoints.
+    # Validates payloads for POST /v2/charts/historical (daily OHLC). No interval.
     class HistoricalDataContract < BaseContract
       params do
-        # Common required fields
         required(:security_id).filled(:string)
-        required(:exchange_segment).filled(:string, included_in?: EXCHANGE_SEGMENTS)
+        required(:exchange_segment).filled(:string, included_in?: CHART_EXCHANGE_SEGMENTS)
         required(:instrument).filled(:string, included_in?: INSTRUMENTS)
+        required(:from_date).filled(:string, format?: /\A\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2})?\z/)
+        required(:to_date).filled(:string, format?: /\A\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2})?\z/)
 
-        # Date range required for both Daily & Intraday
-        required(:from_date).filled(:string, format?: /\A\d{4}-\d{2}-\d{2}\z/)
-        required(:to_date).filled(:string, format?: /\A\d{4}-\d{2}-\d{2}\z/)
-
-        # Optional fields
-        optional(:expiry_code).maybe(:integer, included_in?: [0, 1, 2])
-
-        # For intraday, the user can supply an "interval"
-        # (valid: 1, 5, 15, 25, 60)
-        optional(:interval).maybe(:string, included_in?: %w[1 5 15 25 60])
+        optional(:expiry_code).maybe(:integer, included_in?: ExpiryCode::ALL)
+        optional(:interval).maybe(:string, included_in?: CHART_INTERVALS)
+        optional(:oi).maybe(:bool)
       end
 
       rule(:from_date) do
-        next unless value.is_a?(String) && value.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+        next unless value.is_a?(String) && value.match?(/\A\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2})?\z/)
 
-        d = Date.parse(value)
-        key.failure("must be a valid trading date (no weekend dates)") unless trading_day?(d)
+        # Only validate weekend for pure date strings (YYYY-MM-DD)
+        if value.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+          d = Date.parse(value)
+          key.failure("must be a valid trading date (no weekend dates)") unless trading_day?(d)
+        end
       rescue Date::Error
         key.failure("invalid date format")
       end
 
       rule(:from_date, :to_date) do
-        next unless values[:from_date].match?(/\A\d{4}-\d{2}-\d{2}\z/) && values[:to_date].match?(/\A\d{4}-\d{2}-\d{2}\z/)
+        next unless values[:from_date].match?(/\A\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2})?\z/) &&
+                    values[:to_date].match?(/\A\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2})?\z/)
 
-        from_date = Date.parse(values[:from_date])
-        to_date = Date.parse(values[:to_date])
+        from_date = DateTime.parse(values[:from_date])
+        to_date = DateTime.parse(values[:to_date])
         key.failure("from_date must be before to_date") if from_date >= to_date
       rescue Date::Error
         key.failure("invalid date format")

data/lib/DhanHQ/contracts/intraday_historical_data_contract.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates payloads for POST /v2/charts/intraday (minute OHLC). Requires interval.
+    class IntradayHistoricalDataContract < HistoricalDataContract
+      params do
+        required(:interval).filled(:string, included_in?: CHART_INTERVALS)
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/margin_calculator_contract.rb

@@ -2,39 +2,41 @@
 
 module DhanHQ
   module Contracts
-    # Validates requests sent to the margin calculator endpoint.
-    class MarginCalculatorContract < Dry::Validation::Contract
+    # Validates request for POST /v2/margincalculator (single order).
+    # dhanClientId, exchangeSegment (NSE_EQ|NSE_FNO|BSE_EQ|BSE_FNO|MCX_COMM), transactionType, quantity,
+    # productType (CNC|INTRADAY|MARGIN|MTF), securityId, price (required);
+    # orderType (optional, but required by some accounts); triggerPrice (optional, for SL-M/SL-L).
+    class MarginCalculatorContract < BaseContract
       params do
         required(:dhanClientId).filled(:string)
-        required(:exchangeSegment).filled(:string, included_in?: DhanHQ::Constants::ExchangeSegment::ALL)
-        required(:transactionType).filled(:string, included_in?: DhanHQ::Constants::TransactionType::ALL)
+        required(:exchangeSegment).filled(:string, included_in?: MARGIN_CALCULATOR_SEGMENTS)
+        required(:transactionType).filled(:string, included_in?: TRANSACTION_TYPES)
         required(:quantity).filled(:integer, gt?: 0)
-        required(:productType).filled(:string, included_in?: DhanHQ::Constants::ProductType::ALL)
+        required(:productType).filled(:string, included_in?: MARGIN_PRODUCT_TYPES)
+        optional(:orderType).maybe(:string, included_in?: ORDER_TYPES)
         required(:securityId).filled(:string)
-        optional(:price).maybe(:float, gt?: 0)
+        required(:price).filled(:float, gt?: 0)
         optional(:triggerPrice).maybe(:float)
       end
+
       rule(:price) do
-        if values[:price]
-          if values[:price] <= 0
-            key(:price).failure("must be greater than 0")
-          elsif values[:price].is_a?(Float) && (values[:price].nan? || values[:price].infinite?)
-            key(:price).failure("must be a finite number")
-          end
-        end
+        next unless values[:price].is_a?(Float)
+
+        key.failure("must be a finite number") if values[:price].nan? || values[:price].infinite?
       end
 
       rule(:triggerPrice) do
-        key(:triggerPrice).failure("must be a finite number") if values[:triggerPrice].is_a?(Float) && (values[:triggerPrice].nan? || values[:triggerPrice].infinite?)
+        next unless values[:triggerPrice].is_a?(Float)
+
+        key.failure("must be a finite number") if values[:triggerPrice].nan? || values[:triggerPrice].infinite?
       end
 
-      # Segment-Based Product Restrictions for margin calculations
       rule(:productType, :exchangeSegment) do
         case values[:productType]
         when DhanHQ::Constants::ProductType::CNC, DhanHQ::Constants::ProductType::MTF
-          key(:productType).failure("is only allowed for Equity segments (NSE_EQ, BSE_EQ)") unless /_EQ$/.match?(values[:exchangeSegment])
+          key.failure("is only allowed for Equity segments (NSE_EQ, BSE_EQ)") unless values[:exchangeSegment].to_s.end_with?("_EQ")
         when DhanHQ::Constants::ProductType::MARGIN
-          key(:productType).failure("is not allowed for Equity Cash segments; use CNC or INTRADAY") if /_EQ$/.match?(values[:exchangeSegment])
+          key.failure("is not allowed for Equity Cash segments; use CNC or INTRADAY") if values[:exchangeSegment].to_s.end_with?("_EQ")
         end
       end
     end

data/lib/DhanHQ/contracts/market_feed_contract.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates request payloads for Market Feed endpoints (LTP, OHLC, Quote).
+    #
+    # The Market Feed API expects a payload where keys are Exchange Segments
+    # and values are Arrays of security IDs (Integers).
+    #
+    # @example Valid payload:
+    #   {
+    #     "NSE_EQ": [11536, 3456],
+    #     "NSE_FNO": [49081, 49082]
+    #   }
+    #
+    class MarketFeedContract < BaseContract
+      params do
+        config.validate_keys = true
+
+        # Dynamically define all valid exchange segments as optional keys.
+        # Each must be an array of integers.
+        EXCHANGE_SEGMENTS.each do |segment|
+          optional(segment.to_sym).array(:integer)
+        end
+      end
+
+      rule do
+        base.failure("must provide at least one exchange segment and security ID") if values.to_h.empty?
+
+        total_instruments = 0
+        values.to_h.each do |key, value|
+          if value.is_a?(Array)
+            key(key).failure("must not be empty") if value.empty?
+            total_instruments += value.size
+          end
+        end
+
+        base.failure("cannot fetch more than 1000 instruments in a single request (found #{total_instruments})") if total_instruments > 1000
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/multi_scrip_margin_calc_request_contract.rb

@@ -2,20 +2,23 @@
 
 module DhanHQ
   module Contracts
-    # Validates requests for multi-scrip margin calculations.
+    # Validates request for POST /v2/margincalculator/multi.
+    # Top-level: includePosition, includeOrder, dhanClientId, scripList.
+    # Each scrip: exchangeSegment, transactionType, quantity, productType, securityId, price; triggerPrice optional.
     class MultiScripMarginCalcRequestContract < BaseContract
       params do
         optional(:dhanClientId).maybe(:string)
         optional(:includePosition).maybe(:bool)
         optional(:includeOrder).maybe(:bool)
         required(:scripList).array(:hash) do
-          required(:exchangeSegment).filled(:string, included_in?: EXCHANGE_SEGMENTS)
+          required(:exchangeSegment).filled(:string, included_in?: MARGIN_CALCULATOR_SEGMENTS)
           required(:transactionType).filled(:string, included_in?: TRANSACTION_TYPES)
           required(:quantity).filled(:integer, gt?: 0)
-          required(:productType).filled(:string, included_in?: PRODUCT_TYPES)
+          required(:productType).filled(:string, included_in?: MARGIN_PRODUCT_TYPES)
+          optional(:orderType).maybe(:string, included_in?: ORDER_TYPES)
           required(:securityId).filled(:string)
-          optional(:price).maybe(:float, gt?: 0)
-          optional(:triggerPrice).maybe(:float, gt?: 0)
+          required(:price).filled(:float, gt?: 0)
+          optional(:triggerPrice).maybe(:float)
         end
       end
     end

data/lib/DhanHQ/contracts/option_chain_contract.rb

@@ -1,40 +1,38 @@
 # frozen_string_literal: true
 
-require_relative "base_contract"
+require "date"
 
 module DhanHQ
   module Contracts
-    # **Validation contract for fetching option chain data**
-    #
-    # Validates request parameters for fetching option chains.
+    # Validates request for POST /v2/optionchain (option chain by underlying and expiry).
+    # UnderlyingScrip (int), UnderlyingSeg (enum), Expiry (YYYY-MM-DD). Rate limit: 1 request per 3 seconds.
     class OptionChainContract < BaseContract
       params do
-        required(:underlying_scrip).filled(:integer) # Security ID
-        required(:underlying_seg).filled(:string, included_in?: %w[IDX_I NSE_FNO BSE_FNO MCX_FO])
+        required(:underlying_scrip).filled(:integer)
+        required(:underlying_seg).filled(:string, included_in?: OPTION_CHAIN_UNDERLYING_SEGMENTS)
         required(:expiry).filled(:string)
       end
 
       rule(:expiry) do
-        # Ensure the expiry date is in "YYYY-MM-DD" format
-        key.failure("must be in 'YYYY-MM-DD' format") unless value.match?(/^\d{4}-\d{2}-\d{2}$/)
+        next unless value.is_a?(String)
 
-        # Ensure it is a valid date
-        begin
-          parsed_date = Date.parse(value)
-          key.failure("must be a valid date") unless parsed_date.to_s == value
-        rescue ArgumentError
-          key.failure("is not a valid date")
+        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
     end
 
-    # **Validation contract for fetching option chain expiry list**
-    #
-    # Validates request parameters for fetching expiry lists (expiry not required).
+    # Validates request for POST /v2/optionchain/expirylist (expiry list for an underlying).
+    # UnderlyingScrip (int), UnderlyingSeg (enum). No Expiry.
     class OptionChainExpiryListContract < BaseContract
       params do
-        required(:underlying_scrip).filled(:integer) # Security ID
-        required(:underlying_seg).filled(:string, included_in?: %w[IDX_I NSE_FNO BSE_FNO MCX_FO])
+        required(:underlying_scrip).filled(:integer)
+        required(:underlying_seg).filled(:string, included_in?: OPTION_CHAIN_UNDERLYING_SEGMENTS)
       end
     end
   end

data/lib/DhanHQ/contracts/pnl_based_exit_contract.rb

@@ -13,7 +13,7 @@ module DhanHQ
       end
 
       rule(:profitValue, :lossValue) do
-        key.failure("at least one of profitValue or lossValue must be provided") if !values[:profitValue] && !values[:lossValue]
+        key.failure("at least one of profitValue or lossValue must be provided") unless values[:profitValue] || values[:lossValue]
       end
     end
   end