DhanHQ 2.6.2 → 2.6.3

data/lib/DhanHQ/models/alert_order.rb

@@ -8,7 +8,7 @@ module DhanHQ
     class AlertOrder < BaseModel
       include Concerns::ApiResponseHandler
 
-      HTTP_PATH = "/alerts/orders"
+      HTTP_PATH = "/v2/alerts/orders"
 
       attributes :alert_id, :exchange_segment, :security_id, :condition,
                  :trigger_price, :order_type, :transaction_type, :quantity,
@@ -37,6 +37,8 @@ module DhanHQ
           return nil unless response.is_a?(Hash) || (response.is_a?(Array) && response.any?)
 
           payload = response.is_a?(Array) ? response.first : response
+          return nil if payload.is_a?(Hash) && payload.empty?
+
           new(payload, skip_validation: true)
         end
 
@@ -65,7 +67,9 @@ module DhanHQ
         #
         def modify(alert_id, params)
           normalized = snake_case(params)
-          response = resource.update(alert_id, camelize_keys(normalized))
+          validate_params!(normalized, DhanHQ::Contracts::AlertOrderContract)
+          payload = normalized.merge(alert_id: alert_id)
+          response = resource.update(alert_id, camelize_keys(payload))
           return nil unless success_response?(response)
 
           find(alert_id)

data/lib/DhanHQ/models/edis.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../contracts/edis_contract"
+
 module DhanHQ
   module Models
     ##
@@ -16,15 +18,15 @@ module DhanHQ
     #     isin: "INE155A01022",
     #     qty: 10,
     #     exchange: "NSE",
-    #     segment: "E",
+    #     segment: "EQ",
     #     bulk: false
     #   )
     #
-    # @example Check EDIS status for a security
+    # @example Check EDIS status for a security (or "ALL" for all holdings)
     #   status = DhanHQ::Models::Edis.inquire(isin: "INE155A01022")
     #
     class Edis < BaseModel
-      HTTP_PATH = "/edis"
+      HTTP_PATH = "/v2/edis"
 
       class << self
         ##
@@ -52,24 +54,26 @@ module DhanHQ
         ##
         # Generate an eDIS form for authorizing sale of holdings.
         #
-        # @param isin [String] ISIN of the security (e.g., "INE155A01022")
+        # @param isin [String] ISIN of the security (e.g. "INE733E01010")
         # @param qty [Integer] Quantity to authorize for sale
-        # @param exchange [String] Exchange name (e.g., "NSE", "BSE")
-        # @param segment [String] Segment identifier (e.g., "E")
-        # @param bulk [Boolean] Whether this is a bulk authorization (default: false)
+        # @param exchange [String] Exchange: "NSE" or "BSE"
+        # @param segment [String] Segment: "EQ", "COMM", or "FNO"
+        # @param bulk [Boolean] If true, mark eDIS for all stocks in portfolio (default: false)
         #
-        # @return [Hash] API response containing the eDIS form data
+        # @return [Hash] API response with dhanClientId and edisFormHtml (escaped HTML to render)
         #
         # @example Authorize sale of 10 shares
         #   DhanHQ::Models::Edis.generate_form(
         #     isin: "INE155A01022",
         #     qty: 10,
         #     exchange: "NSE",
-        #     segment: "E"
+        #     segment: "EQ"
         #   )
         #
         def generate_form(isin:, qty:, exchange:, segment:, bulk: false)
-          resource.form({ isin: isin, qty: qty, exchange: exchange, segment: segment, bulk: bulk })
+          params = { isin: isin, qty: qty, exchange: exchange, segment: segment, bulk: bulk }
+          validate_params!(params, DhanHQ::Contracts::EdisFormContract)
+          resource.form(params)
         end
 
         ##
@@ -85,13 +89,16 @@ module DhanHQ
         ##
         # Check EDIS authorization status for a security.
         #
-        # @param isin [String] ISIN of the security to check
+        # @param isin [String] ISIN of the security, or "ALL" for all holdings
         #
-        # @return [Hash] API response containing authorization status
+        # @return [Hash] API response with clientId, isin, totalQty, aprvdQty, status, remarks
         #
-        # @example Check if EDIS is authorized
+        # @example Check if EDIS is authorized for one security
         #   status = DhanHQ::Models::Edis.inquire(isin: "INE155A01022")
         #
+        # @example Check EDIS status for all holdings
+        #   status = DhanHQ::Models::Edis.inquire(isin: "ALL")
+        #
         def inquire(isin:)
           resource.inquire(isin)
         end

data/lib/DhanHQ/models/expired_options_data.rb

@@ -42,7 +42,12 @@ module DhanHQ
     #   call_data = data.call_data
     #   put_data = data.put_data
     #
+    # @example Normalize to candles
+    #   candles = data.to_candles
+    #
     class ExpiredOptionsData < BaseModel
+      OHLC_FIELDS = %i[open high low close iv volume strike spot oi open_interest].freeze
+
       # All expired options data attributes
       attributes :exchange_segment, :interval, :security_id, :instrument,
                  :expiry_flag, :expiry_code, :strike, :drv_option_type,
@@ -56,63 +61,29 @@ module DhanHQ
         # 31 days in a single request. Historical data is available for up to the last 5 years.
         #
         # @param params [Hash{Symbol => String, Integer, Array<String>}] Request parameters
+        #   @option params [String, Integer] :security_id (required) Underlying exchange standard ID for each scrip
         #   @option params [String] :exchange_segment (required) Exchange and segment identifier.
-        #     Valid values: "NSE_FNO", "BSE_FNO", "NSE_EQ", "BSE_EQ"
-        #   @option params [String] :interval (required) Minute intervals for the timeframe.
-        #     Valid values: "1", "5", "15", "25", "60"
-        #   @option params [Integer] :security_id (required) Underlying exchange standard ID for each scrip
+        #     Valid values: "NSE_FNO", "IDX_I", "NSE_EQ", "BSE_EQ"
         #   @option params [String] :instrument (required) Instrument type of the scrip.
         #     Valid values: "OPTIDX" (Index Options), "OPTSTK" (Stock Options)
+        #   @option params [String, Integer] :interval (required) Minute intervals for the timeframe.
+        #     Valid values: "1", "5", "15", "25", "60"
         #   @option params [String] :expiry_flag (required) Expiry interval of the instrument.
         #     Valid values: "WEEK", "MONTH"
         #   @option params [Integer] :expiry_code (required) Expiry code for the instrument
         #   @option params [String] :strike (required) Strike price specification.
         #     Format: "ATM" for At The Money, "ATM+X" or "ATM-X" for offset strikes.
-        #     For Index Options (near expiry): Up to ATM+10 / ATM-10
-        #     For all other contracts: Up to ATM+3 / ATM-3
-        #   @option params [String] :drv_option_type (required) Option type.
-        #     Valid values: "CALL", "PUT"
+        #   @option params [String] :option_type (required) Option type ("CALL" or "PUT").
         #   @option params [Array<String>] :required_data (required) Array of required data fields.
-        #     Valid values: "open", "high", "low", "close", "iv", "volume", "strike", "oi", "spot"
-        #   @option params [String] :from_date (required) Start date of the desired range in YYYY-MM-DD format.
-        #     Cannot be more than 5 years ago. Same-day ranges are allowed.
-        #   @option params [String] :to_date (required) End date of the desired range (non-inclusive) in YYYY-MM-DD format.
-        #     Date range cannot exceed 31 days from from_date (to_date is non-inclusive). Same-day `from_date`/`to_date` is valid.
+        #   @option params [String] :from_date (required) Start date in YYYY-MM-DD format.
+        #   @option params [String] :to_date (required) End date in YYYY-MM-DD format.
         #
         # @return [ExpiredOptionsData] Expired options data object with fetched data
-        #
-        # @example Fetch NIFTY index options data
-        #   data = DhanHQ::Models::ExpiredOptionsData.fetch(
-        #     exchange_segment: "NSE_FNO",
-        #     interval: "1",
-        #     security_id: 13,
-        #     instrument: "OPTIDX",
-        #     expiry_flag: "MONTH",
-        #     expiry_code: 1,
-        #     strike: "ATM",
-        #     drv_option_type: "CALL",
-        #     required_data: ["open", "high", "low", "close", "volume", "iv", "oi", "spot"],
-        #     from_date: "2021-08-01",
-        #     to_date: "2021-09-01"
-        #   )
-        #
-        # @example Fetch stock options data for ATM+2 strike
-        #   data = DhanHQ::Models::ExpiredOptionsData.fetch(
-        #     exchange_segment: "NSE_FNO",
-        #     interval: "15",
-        #     security_id: 11536,
-        #     instrument: "OPTSTK",
-        #     expiry_flag: "WEEK",
-        #     expiry_code: 0,
-        #     strike: "ATM+2",
-        #     drv_option_type: "PUT",
-        #     required_data: ["open", "high", "low", "close", "volume"],
-        #     from_date: "2024-01-01",
-        #     to_date: "2024-01-31"
-        #   )
-        #
         # @raise [DhanHQ::ValidationError] If validation fails for any parameter
         def fetch(params)
+          # Map option_type to drv_option_type if provided
+          params[:drv_option_type] ||= params[:option_type] if params.key?(:option_type)
+
           normalized = normalize_params(params)
           validate_params(normalized)
 
@@ -120,6 +91,8 @@ module DhanHQ
           new(response.merge(normalized), skip_validation: true)
         end
 
+        alias rolling fetch
+
         private
 
         def expired_options_resource
@@ -180,6 +153,43 @@ module DhanHQ
         end
       end
 
+      ##
+      # Normalizes the columnar response into an array of candle hashes.
+      #
+      # @param option_type [String, nil] Option type to retrieve ("CALL" or "PUT").
+      #   If nil, uses the {#drv_option_type} from the request.
+      # @return [Array<Hash>] Normalized array of candles.
+      def to_candles(option_type = nil)
+        option_type ||= drv_option_type
+        opt_data = data_for_type(option_type)
+        return [] unless opt_data.is_a?(Hash)
+
+        # Standardize keys to symbols
+        opt_data = opt_data.transform_keys(&:to_sym)
+        ts_arr = opt_data[:timestamp]
+        return [] unless ts_arr.is_a?(Array)
+
+        type_sym = option_type.to_s.downcase.to_sym
+
+        ts_arr.each_with_index.map do |ts, i|
+          candle = {
+            option_type: type_sym,
+            timestamp: ts.is_a?(Numeric) ? Time.at(ts) : ts
+          }
+
+          # Map requested fields
+          OHLC_FIELDS.each do |field|
+            val_arr = opt_data[field]
+            next unless val_arr.is_a?(Array)
+
+            # Map 'oi' to 'open_interest' if requested
+            target_field = field == :oi ? :open_interest : field
+            candle[target_field] = val_arr[i]
+          end
+          candle
+        end
+      end
+
       ##
       # Gets call option data from the response.
       #

data/lib/DhanHQ/models/forever_order.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../contracts/forever_order_contract"
+
 module DhanHQ
   module Models
     ##
@@ -154,9 +156,9 @@ module DhanHQ
         #   @option params [String] :transaction_type (required) The trading side of transaction.
         #     Valid values: "BUY", "SELL"
         #   @option params [String] :exchange_segment (required) Exchange and segment identifier.
-        #     Valid values: "NSE_EQ", "NSE_FNO", "BSE_EQ", "BSE_FNO"
+        #     Valid values: See {DhanHQ::Constants::FOREVER_ORDER_SEGMENTS} (NSE_EQ, NSE_FNO, BSE_EQ, BSE_FNO, MCX_COMM)
         #   @option params [String] :product_type (required) Product type.
-        #     Valid values: "CNC", "MTF"
+        #     Valid values: See {DhanHQ::Constants::FOREVER_ORDER_PRODUCT_TYPES} (CNC, MTF)
         #   @option params [String] :order_type (required) Order type.
         #     Valid values: "LIMIT", "MARKET"
         #   @option params [String] :validity (required) Validity of order for execution.
@@ -216,11 +218,12 @@ module DhanHQ
         #
         # @note Order placement APIs require Static IP whitelisting
         def create(params)
-          # Normalize params and auto-inject dhan_client_id from configuration if not provided
-          normalized_params = snake_case(params)
+          normalized = snake_case(params)
           config = DhanHQ.configuration
-          normalized_params[:dhan_client_id] ||= config.client_id if config&.client_id
-          response = resource.create(normalized_params)
+          normalized[:dhan_client_id] ||= config.client_id if config&.client_id
+          validate_params!(normalized, DhanHQ::Contracts::ForeverOrderCreateContract)
+          formatted = camelize_keys(normalized)
+          response = resource.create(formatted)
           return nil unless response.is_a?(Hash) && response["orderId"]
 
           find(response["orderId"])
@@ -292,7 +295,13 @@ module DhanHQ
         raise "Order ID is required to modify a forever order" unless order_id
 
         DhanHQ.logger&.info("[DhanHQ::Models::ForeverOrder] Modifying order #{order_id}")
-        response = self.class.resource.update(order_id, new_params)
+        full_params = snake_case(new_params)
+        config = DhanHQ.configuration
+        full_params[:dhan_client_id] ||= config.client_id if config&.client_id
+        full_params[:order_id] = order_id
+        validate_params!(full_params, DhanHQ::Contracts::ForeverOrderModifyContract)
+        formatted = camelize_keys(full_params)
+        response = self.class.resource.update(order_id, formatted)
         ctx = "[DhanHQ::Models::ForeverOrder] Modification"
         success = handle_api_response(response, success_key: "orderId", context: ctx)
         return self.class.find(order_id) if success

data/lib/DhanHQ/models/historical_data.rb

@@ -56,11 +56,11 @@ module DhanHQ
         # @param params [Hash{Symbol => String, Integer, Boolean}] Request parameters
         #   @option params [String] :security_id (required) Exchange standard ID for each scrip
         #   @option params [String] :exchange_segment (required) Exchange and segment for which data is to be fetched.
-        #     Valid values: See {DhanHQ::Constants::EXCHANGE_SEGMENTS}
+        #     Valid values: See {DhanHQ::Constants::CHART_EXCHANGE_SEGMENTS}
         #   @option params [String] :instrument (required) Instrument type of the scrip.
         #     Valid values: See {DhanHQ::Constants::INSTRUMENTS}
         #   @option params [Integer] :expiry_code (optional) Expiry of the instruments in case of derivatives.
-        #     Valid values: 0, 1, 2
+        #     Valid values: See {DhanHQ::Constants::ExpiryCode::ALL} (0, 1, 2)
         #   @option params [Boolean] :oi (optional) Include Open Interest data for Futures & Options.
         #     Default: false
         #   @option params [String] :from_date (required) Start date of the desired range in YYYY-MM-DD format
@@ -100,8 +100,9 @@ module DhanHQ
         #
         # @raise [DhanHQ::ValidationError] If validation fails for any parameter
         def daily(params)
-          validate_params!(params, DhanHQ::Contracts::HistoricalDataContract)
-          resource.daily(params)
+          validated_params = validate_params!(params, DhanHQ::Contracts::HistoricalDataContract)
+          response = resource.daily(validated_params)
+          normalize(response)
         end
 
         ##
@@ -177,8 +178,41 @@ module DhanHQ
         #   make multiple requests or store data locally for analysis.
         # @raise [DhanHQ::ValidationError] If validation fails for any parameter
         def intraday(params)
-          validate_params!(params, DhanHQ::Contracts::HistoricalDataContract)
-          resource.intraday(params)
+          validated_params = validate_params!(params, DhanHQ::Contracts::IntradayHistoricalDataContract)
+          response = resource.intraday(validated_params)
+          normalize(response)
+        end
+
+        private
+
+        # Normalizes the columnar API response into an array of candle hashes.
+        #
+        # @param response [Hash] The raw API response
+        # @return [Array<Hash>, Hash] Normalized array of candles, or raw response if structure unexpected
+        def normalize(response)
+          # Use symbols or strings depending on HashWithIndifferentAccess behavior
+          close = response[:close] || response["close"]
+          return response unless response.is_a?(Hash) && close.is_a?(Array)
+
+          ts = response[:timestamp] || response["timestamp"]
+          open = response[:open] || response["open"]
+          high = response[:high] || response["high"]
+          low = response[:low] || response["low"]
+          volume = response[:volume] || response["volume"]
+          oi = response[:open_interest] || response["open_interest"]
+
+          (0...close.size).map do |i|
+            candle = {
+              timestamp: ts[i].is_a?(Numeric) ? Time.at(ts[i]) : ts[i],
+              open: open[i],
+              high: high[i],
+              low: low[i],
+              close: close[i],
+              volume: volume[i]
+            }
+            candle[:open_interest] = oi[i] if oi && oi[i]
+            candle
+          end
         end
       end
     end

data/lib/DhanHQ/models/instrument_helpers.rb

@@ -161,7 +161,8 @@ module DhanHQ
         return seg if %w[IDX_I NSE_FNO BSE_FNO MCX_FO].include?(seg)
 
         # Index detection by instrument kind or segment
-        return DhanHQ::Constants::ExchangeSegment::IDX_I if ins == DhanHQ::Constants::InstrumentType::INDEX || seg == DhanHQ::Constants::ExchangeSegment::IDX_I
+        idx_seg = DhanHQ::Constants::ExchangeSegment::IDX_I
+        return idx_seg if ins == DhanHQ::Constants::InstrumentType::INDEX || seg == idx_seg
 
         # Map equities/stock-related segments to respective FNO
         return DhanHQ::Constants::ExchangeSegment::NSE_FNO if seg.start_with?("NSE")

data/lib/DhanHQ/models/margin.rb

@@ -48,7 +48,9 @@ module DhanHQ
       HTTP_PATH = "/v2/margincalculator"
 
       attributes :total_margin, :span_margin, :exposure_margin, :available_balance,
-                 :variable_margin, :insufficient_balance, :brokerage, :leverage
+                 :variable_margin, :insufficient_balance, :brokerage, :leverage,
+                 :client_id, :equity_margin, :fo_margin, :commodity_margin,
+                 :currency, :hedge_benefit, :exposure, :commodity
 
       class << self
         ##
@@ -70,28 +72,18 @@ module DhanHQ
         #   @option params [String] :dhan_client_id (required) User-specific identification generated by Dhan.
         #     Must be explicitly provided in the params hash
         #   @option params [String] :exchange_segment (required) Exchange and segment identifier.
-        #     Valid values: "NSE_EQ", "NSE_FNO", "BSE_EQ", "BSE_FNO", "MCX_COMM"
+        #     Valid values: See {DhanHQ::Constants::MARGIN_CALCULATOR_SEGMENTS} (NSE_EQ, NSE_FNO, BSE_EQ, BSE_FNO, MCX_COMM)
         #   @option params [String] :transaction_type (required) The trading side of transaction.
         #     Valid values: "BUY", "SELL"
         #   @option params [Integer] :quantity (required) Number of shares for the order. Must be greater than 0
         #   @option params [String] :product_type (required) Product type.
-        #     Valid values: "CNC", "INTRADAY", "MARGIN", "MTF", "CO", "BO"
+        #     Valid values: See {DhanHQ::Constants::MARGIN_PRODUCT_TYPES} (CNC, INTRADAY, MARGIN, MTF)
         #   @option params [String] :security_id (required) Exchange standard ID for each scrip
         #   @option params [Float] :price (required) Price at which order is placed. Must be greater than 0
         #   @option params [Float] :trigger_price (conditionally required) Price at which the order is triggered.
         #     Required for STOP_LOSS and STOP_LOSS_MARKET order types
         #
         # @return [Margin] Margin object containing margin calculation results.
-        #   Response structure (keys normalized to snake_case):
-        #   - **:total_margin** [Float] Total margin required for placing the order successfully
-        #   - **:span_margin** [Float] SPAN margin required
-        #   - **:exposure_margin** [Float] Exposure margin required
-        #   - **:available_balance** [Float] Available amount in trading account
-        #   - **:variable_margin** [Float] VAR or Variable margin required
-        #   - **:insufficient_balance** [Float] Insufficient amount in trading account
-        #     (Available Balance - Total Margin). Negative or zero indicates sufficient margin
-        #   - **:brokerage** [Float] Brokerage charges for executing the order
-        #   - **:leverage** [String] Margin leverage provided for the order as per product type
         #
         # @example Calculate margin for CNC equity order
         #   margin = DhanHQ::Models::Margin.calculate(
@@ -106,31 +98,6 @@ module DhanHQ
         #   puts "Total Margin: ₹#{margin.total_margin}"
         #   puts "Brokerage: ₹#{margin.brokerage}"
         #
-        # @example Calculate margin for intraday order
-        #   margin = DhanHQ::Models::Margin.calculate(
-        #     dhan_client_id: "1000000132",
-        #     exchange_segment: "NSE_EQ",
-        #     transaction_type: "SELL",
-        #     quantity: 10,
-        #     product_type: "INTRADAY",
-        #     security_id: "1333",
-        #     price: 1500.0
-        #   )
-        #   puts "Leverage: #{margin.leverage}x"
-        #   puts "SPAN Margin: ₹#{margin.span_margin}"
-        #
-        # @example Calculate margin for stop-loss order
-        #   margin = DhanHQ::Models::Margin.calculate(
-        #     dhan_client_id: "1000000132",
-        #     exchange_segment: "NSE_EQ",
-        #     transaction_type: "BUY",
-        #     quantity: 5,
-        #     product_type: "INTRADAY",
-        #     security_id: "1333",
-        #     price: 1428.0,
-        #     trigger_price: 1427.0
-        #   )
-        #
         # @raise [DhanHQ::ValidationError] If validation fails for any parameter
         def calculate(params)
           formatted_params = camelize_keys(params)
@@ -148,45 +115,68 @@ module DhanHQ
         #
         # @param params [Hash{Symbol => Object}] Request parameters
         #   @option params [Boolean] :include_position Whether to include existing positions
-        #   @option params [Boolean] :include_order Whether to include existing orders
+        #   @option params [Boolean] :include_orders Whether to include existing orders
         #   @option params [String] :dhan_client_id User-specific identification
-        #   @option params [Array<Hash>] :scrip_list Array of instrument margin params, each with:
-        #     - :exchange_segment [String]
-        #     - :transaction_type [String]
+        #   @option params [Array<Hash>] :scripts Array of instrument margin params, each with:
+        #     - :exchange_segment [String] See {DhanHQ::Constants::MARGIN_CALCULATOR_SEGMENTS}
+        #     - :transaction_type [String] BUY or SELL
         #     - :quantity [Integer]
-        #     - :product_type [String]
+        #     - :product_type [String] See {DhanHQ::Constants::MARGIN_PRODUCT_TYPES}
         #     - :security_id [String]
-        #     - :price [Float]
+        #     - :price [Float] (required)
         #     - :trigger_price [Float] (optional)
         #
-        # @return [Hash{Symbol => String}] Response hash containing:
-        #   - **:total_margin** [String] Total margin required
-        #   - **:span_margin** [String] SPAN margin
-        #   - **:exposure_margin** [String] Exposure margin
-        #   - **:equity_margin** [String] Equity margin
-        #   - **:fo_margin** [String] F&O margin
-        #   - **:commodity_margin** [String] Commodity margin
-        #   - **:currency** [String] Currency (e.g., "INR")
-        #   - **:hedge_benefit** [String] Hedge benefit amount
+        # @return [Margin] Margin object containing combined results.
         #
         # @example Calculate margin for multiple scripts
-        #   result = DhanHQ::Models::Margin.calculate_multi(
+        #   margin = DhanHQ::Models::Margin.calculate_multi(
         #     include_position: true,
-        #     include_order: true,
-        #     dhan_client_id: "1000000132",
-        #     scrip_list: [
+        #     include_orders: true,
+        #     scripts: [
         #       { exchange_segment: "NSE_EQ", transaction_type: "BUY",
         #         quantity: 100, product_type: "CNC", security_id: "1333", price: 1428.0 },
-        #       { exchange_segment: "NSE_FNO", transaction_type: "SELL",
-        #         quantity: 50, product_type: "INTRADAY", security_id: "43492", price: 200.0 }
+        #       { exchange_segment: "NSE_EQ", transaction_type: "SELL",
+        #         quantity: 50, product_type: "INTRADAY", security_id: "11536", price: 3000.0 }
         #     ]
         #   )
-        #   puts "Total margin: #{result[:total_margin]}"
-        #   puts "Hedge benefit: #{result[:hedge_benefit]}"
+        #   puts "Total margin: #{margin.total_margin}"
         #
         def calculate_multi(params)
-          formatted_params = camelize_keys(params)
-          resource.calculate_multi(formatted_params)
+          # Map scripts to scrip_list and include_orders to include_order if provided
+          params[:scrip_list] ||= params[:scripts] if params.key?(:scripts)
+          params[:include_order] ||= params[:include_orders] if params.key?(:include_orders)
+          params[:dhan_client_id] ||= DhanHQ.configuration.client_id
+
+          # Filter only keys supported by the API
+          filtered_params = {
+            includePosition: params[:include_position],
+            includeOrder: params[:include_order],
+            dhanClientId: params[:dhan_client_id],
+            scripList: params[:scrip_list]
+          }
+
+          if filtered_params[:scripList].is_a?(Array)
+            filtered_params[:scripList] = filtered_params[:scripList].map do |scrip|
+              if scrip.is_a?(Hash)
+                {
+                  exchangeSegment: scrip[:exchange_segment] || scrip[:exchangeSegment],
+                  transactionType: scrip[:transaction_type] || scrip[:transactionType],
+                  quantity: scrip[:quantity],
+                  productType: scrip[:product_type] || scrip[:productType],
+                  orderType: scrip[:order_type] || scrip[:orderType],
+                  securityId: scrip[:security_id] || scrip[:securityId],
+                  price: scrip[:price],
+                  triggerPrice: scrip[:trigger_price] || scrip[:triggerPrice]
+                }.compact
+              else
+                scrip
+              end
+            end
+          end
+
+          validate_params!(filtered_params, DhanHQ::Contracts::MultiScripMarginCalcRequestContract)
+          response = resource.calculate_multi(filtered_params)
+          new(response, skip_validation: true)
         end
       end
 
@@ -195,33 +185,23 @@ module DhanHQ
       #
       # Useful for serialization, logging, or passing margin data to other methods.
       #
-      # @return [Hash{Symbol => Float, String}] Hash representation of the Margin model containing:
-      #   - **:total_margin** [Float] Total margin required
-      #   - **:span_margin** [Float] SPAN margin
-      #   - **:exposure_margin** [Float] Exposure margin
-      #   - **:available_balance** [Float] Available balance
-      #   - **:variable_margin** [Float] Variable margin
-      #   - **:insufficient_balance** [Float] Insufficient balance amount
-      #   - **:brokerage** [Float] Brokerage charges
-      #   - **:leverage** [String] Leverage as string
-      #
-      # @example Convert margin to hash
-      #   margin = DhanHQ::Models::Margin.calculate(params)
-      #   margin_hash = margin.to_h
-      #   puts margin_hash[:total_margin]  # => 2800.00
-      #   puts margin_hash[:leverage]       # => "4.00"
-      #
+      # @return [Hash{Symbol => Float, String}] Hash representation of the Margin model.
       def to_h
         {
           total_margin: total_margin,
           span_margin: span_margin,
-          exposure_margin: exposure_margin,
+          exposure_margin: exposure_margin || exposure,
           available_balance: available_balance,
           variable_margin: variable_margin,
           insufficient_balance: insufficient_balance,
           brokerage: brokerage,
-          leverage: leverage
-        }
+          leverage: leverage,
+          equity_margin: equity_margin,
+          fo_margin: fo_margin,
+          commodity_margin: commodity_margin || commodity,
+          currency: currency,
+          hedge_benefit: hedge_benefit
+        }.compact
       end
     end
   end

data/lib/DhanHQ/models/market_feed.rb

@@ -43,6 +43,14 @@ module DhanHQ
     #
     class MarketFeed < BaseModel
       class << self
+        ##
+        # Returns the validation contract for MarketFeed requests.
+        #
+        # @return [Class] The MarketFeedContract class
+        def validation_contract
+          DhanHQ::Contracts::MarketFeedContract
+        end
+
         ##
         # Provides a shared instance of the MarketFeed resource.
         #
@@ -84,7 +92,8 @@ module DhanHQ
         #   puts "Last Price: ₹#{data[:last_price]}"
         #
         def ltp(params)
-          resource.ltp(params)
+          validated_params = validate_params!(params, validation_contract)
+          resource.ltp(validated_params)
         end
 
         ##
@@ -127,7 +136,8 @@ module DhanHQ
         #   puts "LTP: ₹#{tcs_data[:last_price]}"
         #
         def ohlc(params)
-          resource.ohlc(params)
+          validated_params = validate_params!(params, validation_contract)
+          resource.ohlc(validated_params)
         end
 
         ##
@@ -197,7 +207,8 @@ module DhanHQ
         #   puts "Best Buy Quantity: #{buy_depth[0][:quantity]}"
         #
         def quote(params)
-          resource.quote(params)
+          validated_params = validate_params!(params, validation_contract)
+          resource.quote(validated_params)
         end
       end
     end