DhanHQ 2.4.0 → 2.6.0

data/lib/DhanHQ/contracts/alert_order_contract.rb

@@ -2,18 +2,45 @@
 
 module DhanHQ
   module Contracts
-    # Validates alert order payloads for create/update (exchange_segment, security_id,
-    # condition, trigger_price, transaction_type, quantity; optional price, order_type).
+    # 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.
     class AlertOrderContract < BaseContract
       params do
-        required(:exchange_segment).filled(:string)
-        required(:security_id).filled(:string)
-        required(:condition).filled(:string)
-        required(:trigger_price).filled(:float)
-        required(:transaction_type).filled(:string, included_in?: %w[BUY SELL])
-        required(:quantity).filled(:integer, gt?: 0)
-        optional(:price).maybe(:float)
-        optional(:order_type).maybe(:string)
+        required(:condition).hash do
+          required(:security_id).filled(:string, max_size?: 20)
+          required(:exchange_segment).filled(:string, included_in?: EXCHANGE_SEGMENTS)
+          required(:comparison_type).filled(:string, included_in?: COMPARISON_TYPES)
+          optional(:indicator_name).maybe(:string)
+          optional(:time_frame).maybe(:string)
+          required(:operator).filled(:string, included_in?: OPERATORS)
+          optional(:comparing_value).maybe(:float)
+          optional(:comparing_indicator_name).maybe(:string)
+          required(:exp_date).filled(:string)
+          required(:frequency).filled(: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(: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)
+        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
+      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
       end
     end
   end

data/lib/DhanHQ/contracts/base_contract.rb

@@ -10,6 +10,28 @@ module DhanHQ
     class BaseContract < Dry::Validation::Contract
       # Include constants to make them accessible in all derived contracts
       include DhanHQ::Constants
+
+      # Optional instrument metadata used by subcontracts for lot/tick size validation
+      option :instrument_meta, optional: true
+
+      register_macro(:lot_size_multiple) do
+        meta = _contract.instrument_meta
+        next unless meta && meta[:lot_size]
+
+        ls = meta[:lot_size]
+        key.failure("must be a multiple of lot size (#{ls})") if value && (value % ls != 0)
+      end
+
+      register_macro(:tick_size_multiple) do
+        meta = _contract.instrument_meta
+        next unless meta && meta[:tick_size]
+
+        ts = meta[:tick_size]
+        if value
+          quotient = value.to_f / ts
+          key.failure("must be a multiple of tick size (#{ts})") if (quotient - quotient.round).abs > 1e-6
+        end
+      end
     end
   end
 end

data/lib/DhanHQ/contracts/edis_contract.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates requests for generating EDIS forms.
+    class EdisFormContract < BaseContract
+      params do
+        required(:isin).filled(:string)
+        required(:qty).filled(:integer, gt?: 0)
+        required(:exchange).filled(:string, included_in?: %w[NSE BSE MCX ALL])
+        required(:segment).filled(:string, included_in?: %w[EQ COMM FNO])
+        required(:bulk).filled(:bool)
+      end
+    end
+
+    # Validates requests for generating bulk EDIS forms.
+    class EdisBulkFormContract < BaseContract
+      params do
+        required(:isin).array(:string)
+        required(:exchange).filled(:string, included_in?: %w[NSE BSE MCX ALL])
+        required(:segment).filled(:string, included_in?: %w[EQ COMM FNO])
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/margin_calculator_contract.rb

@@ -6,14 +6,37 @@ module DhanHQ
     class MarginCalculatorContract < Dry::Validation::Contract
       params do
         required(:dhanClientId).filled(:string)
-        required(:exchangeSegment).filled(:string, included_in?: %w[NSE_EQ NSE_FNO BSE_EQ])
-        required(:transactionType).filled(:string, included_in?: %w[BUY SELL])
+        required(:exchangeSegment).filled(:string, included_in?: DhanHQ::Constants::ExchangeSegment::ALL)
+        required(:transactionType).filled(:string, included_in?: DhanHQ::Constants::TransactionType::ALL)
         required(:quantity).filled(:integer, gt?: 0)
-        required(:productType).filled(:string, included_in?: %w[CNC INTRADAY MARGIN MTF CO BO])
+        required(:productType).filled(:string, included_in?: DhanHQ::Constants::ProductType::ALL)
         required(:securityId).filled(:string)
-        required(:price).filled(:float, gt?: 0)
+        optional(:price).maybe(: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
+      end
+
+      rule(:triggerPrice) do
+        key(:triggerPrice).failure("must be a finite number") if values[:triggerPrice].is_a?(Float) && (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])
+        when DhanHQ::Constants::ProductType::MARGIN
+          key(:productType).failure("is not allowed for Equity Cash segments; use CNC or INTRADAY") if /_EQ$/.match?(values[:exchangeSegment])
+        end
+      end
     end
   end
 end

data/lib/DhanHQ/contracts/modify_order_contract.rb

@@ -1,22 +1,75 @@
 # frozen_string_literal: true
 
+require_relative "order_contract"
+
 module DhanHQ
   module Contracts
-    # Validation contract for order modification requests
-    class ModifyOrderContract < Dry::Validation::Contract
+    # Contract for validating order modification requests
+    class ModifyOrderContract < OrderContract
       params do
-        required(:dhanClientId).filled(:string)
-        required(:orderId).filled(:string)
-        optional(:orderType).maybe(:string, included_in?: %w[LIMIT MARKET STOP_LOSS STOP_LOSS_MARKET])
-        optional(:quantity).maybe(:integer)
-        optional(:price).maybe(:float)
-        optional(:triggerPrice).maybe(:float)
-        optional(:disclosedQuantity).maybe(:integer)
-        optional(:validity).maybe(:string, included_in?: %w[DAY IOC])
+        required(:order_id).filled(:string)
+
+        optional(:transaction_type).maybe(:string, included_in?: TRANSACTION_TYPES)
+        optional(:exchange_segment).maybe(:string, included_in?: EXCHANGE_SEGMENTS)
+        optional(:product_type).maybe(:string, included_in?: PRODUCT_TYPES)
+        optional(:order_type).maybe(:string, included_in?: ORDER_TYPES)
+        optional(:validity).maybe(:string, included_in?: VALIDITY_TYPES)
+        optional(:security_id).maybe(:string, max_size?: 20)
+        optional(:quantity).maybe(:integer, gt?: 0)
+
+        optional(:price).maybe(:float, gt?: 0)
+        # Allow 0 for non–stop-loss orders (API often returns triggerPrice: 0); rule below enforces > 0 for SL types.
+        optional(:trigger_price).maybe(:float, gteq?: 0)
+        optional(:disclosed_quantity).maybe(:integer, gteq?: 0)
+
+        optional(:bo_profit_value).maybe(:float, gt?: 0)
+        optional(:bo_stop_loss_value).maybe(:float, gt?: 0)
+        optional(:leg_name).maybe(:string)
+      end
+
+      # --------------------------------------------------
+      # MUST MODIFY AT LEAST ONE EXECUTION FIELD
+      # --------------------------------------------------
+
+      rule do
+        modifiable_fields = %i[
+          quantity price trigger_price disclosed_quantity
+          bo_profit_value bo_stop_loss_value
+          validity order_type
+        ]
+
+        changed = modifiable_fields.any? { |field| values.key?(field) && !values[field].nil? }
+
+        base.failure("at least one modifiable field must be provided") unless changed
+      end
+
+      # --------------------------------------------------
+      # MARKET ORDER RESTRICTION
+      # --------------------------------------------------
+
+      rule(:order_type, :price) do
+        key(:price).failure("cannot modify price for MARKET orders") if values[:order_type] == DhanHQ::Constants::OrderType::MARKET && values[:price]
       end
 
-      rule(:quantity) do
-        key.failure("must be provided if modifying quantity") if value.nil? && values[:price].nil?
+      # --------------------------------------------------
+      # TRIGGER PRICE FOR STOP-LOSS ONLY
+      # --------------------------------------------------
+
+      rule(:order_type, :trigger_price) do
+        if %w[STOP_LOSS STOP_LOSS_MARKET].include?(values[:order_type]) && (values[:trigger_price].nil? || values[:trigger_price].to_f <= 0)
+          key(:trigger_price).failure("must be present and greater than zero for STOP_LOSS orders")
+        end
+      end
+
+      # --------------------------------------------------
+      # BO LEG VALIDATION
+      # --------------------------------------------------
+
+      rule(:leg_name, :product_type) do
+        if values[:product_type] == DhanHQ::Constants::ProductType::BO
+          allowed = %w[ENTRY_LEG TARGET_LEG STOP_LOSS_LEG]
+          key(:leg_name).failure("invalid leg_name for BO order") unless values[:leg_name] && allowed.include?(values[:leg_name])
+        end
       end
     end
   end

data/lib/DhanHQ/contracts/multi_scrip_margin_calc_request_contract.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates requests for multi-scrip margin calculations.
+    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(:transactionType).filled(:string, included_in?: TRANSACTION_TYPES)
+          required(:quantity).filled(:integer, gt?: 0)
+          required(:productType).filled(:string, included_in?: PRODUCT_TYPES)
+          required(:securityId).filled(:string)
+          optional(:price).maybe(:float, gt?: 0)
+          optional(:triggerPrice).maybe(:float, gt?: 0)
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/order_contract.rb

@@ -1,28 +1,20 @@
 # frozen_string_literal: true
 
-# lib/dhan_hq/contracts/order_contract.rb
 require "dry-validation"
+require_relative "base_contract"
 
 module DhanHQ
   module Contracts
-    # Shared contract used to validate place and modify order payloads.
+    # Base contract for validating order placements and rules
     class OrderContract < BaseContract
-      # Allowed transaction directions supported by DhanHQ order APIs.
-      TRANSACTION_TYPES = %w[BUY SELL].freeze
-      # Supported exchange segments for order placement requests.
-      EXCHANGE_SEGMENTS = %w[NSE_EQ NSE_FNO NSE_CURRENCY BSE_EQ MCX_COMM BSE_CURRENCY BSE_FNO].freeze
-      # Permitted product types for order placement.
-      PRODUCT_TYPES = %w[CNC INTRADAY MARGIN CO BO].freeze
-      # Supported order execution types.
-      ORDER_TYPES = %w[LIMIT MARKET STOP_LOSS STOP_LOSS_MARKET].freeze
-      # Validity window options for orders.
-      VALIDITY_TYPES = %w[DAY IOC].freeze
-      # After-market execution windows.
-      AMO_TIMES = %w[PRE_OPEN OPEN OPEN_30 OPEN_60].freeze
+      TRANSACTION_TYPES = DhanHQ::Constants::TransactionType::ALL
+      EXCHANGE_SEGMENTS = DhanHQ::Constants::ExchangeSegment::ALL
+      PRODUCT_TYPES     = DhanHQ::Constants::ProductType::ALL
+      ORDER_TYPES       = DhanHQ::Constants::OrderType::ALL
+      VALIDITY_TYPES    = DhanHQ::Constants::Validity::ALL
+      AMO_TIMES         = DhanHQ::Constants::AmoTime::ALL
 
       params do
-        # Common required fields
-        required(:dhan_client_id).filled(:string)
         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)
@@ -31,47 +23,187 @@ module DhanHQ
         required(:security_id).filled(:string)
         required(:quantity).filled(:integer, gt?: 0)
 
-        # Optional fields
         optional(:correlation_id).maybe(:string)
         optional(:disclosed_quantity).maybe(:integer, gteq?: 0)
-        optional(:price).maybe(:float)
-        optional(:trigger_price).maybe(:float)
+        optional(:price).maybe(:float, gt?: 0)
+        optional(:trigger_price).maybe(:float, gt?: 0)
         optional(:after_market_order).maybe(:bool)
         optional(:amo_time).maybe(:string, included_in?: AMO_TIMES)
-        optional(:bo_profit_value).maybe(:float)
-        optional(:bo_stop_loss_value).maybe(:float)
-        optional(:leg_name).maybe(:string) # For modifications
+        optional(:bo_profit_value).maybe(:float, gt?: 0)
+        optional(:bo_stop_loss_value).maybe(:float, gt?: 0)
+        optional(:leg_name).maybe(:string)
       end
 
-      # Conditional validation rules
-      rule(:price) do
-        key.failure("must be present for LIMIT orders") if values[:order_type] == "LIMIT" && !value
+      # --------------------------------------------------
+      # ORDER TYPE VALIDATION
+      # --------------------------------------------------
+
+      rule(:order_type, :price) do
+        if values[:order_type] == DhanHQ::Constants::OrderType::LIMIT && !values[:price]
+          key(:price).failure("must be present for LIMIT orders")
+        end
+
+        if values[:order_type] == DhanHQ::Constants::OrderType::MARKET && values[:price]
+          key(:price).failure("must not be provided for MARKET orders")
+        end
+
+        if values[:price].is_a?(Float) && (values[:price].nan? || values[:price].infinite?)
+          key(:price).failure("must be a finite number")
+        end
       end
 
-      rule(:trigger_price) do
-        if %w[STOP_LOSS STOP_LOSS_MARKET].include?(values[:order_type]) && !value
-          key.failure("must be present for STOP_LOSS orders")
+      rule(:order_type, :trigger_price) do
+        if %w[STOP_LOSS STOP_LOSS_MARKET].include?(values[:order_type]) && !values[:trigger_price]
+          key(:trigger_price).failure("must be present for STOP_LOSS orders")
         end
       end
 
-      rule(:amo_time) do
-        key.failure("must be present for after market orders") if values[:after_market_order] == true && !value
+      # --------------------------------------------------
+      # STOP LOSS PRICE RELATIONSHIP
+      # --------------------------------------------------
+
+      rule(:order_type, :transaction_type, :price, :trigger_price) do
+        next unless %w[STOP_LOSS STOP_LOSS_MARKET].include?(values[:order_type])
+        next unless values[:price] && values[:trigger_price]
+
+        if values[:transaction_type] == DhanHQ::Constants::TransactionType::BUY
+          if values[:trigger_price] < values[:price]
+            key(:trigger_price).failure("must be >= price for BUY stop-loss")
+          end
+        elsif values[:transaction_type] == DhanHQ::Constants::TransactionType::SELL
+          if values[:trigger_price] > values[:price]
+            key(:trigger_price).failure("must be <= price for SELL stop-loss")
+          end
+        end
       end
 
-      rule(:bo_profit_value, :bo_stop_loss_value) do
-        if values[:product_type] == "BO" && (!values[:bo_profit_value] || !values[:bo_stop_loss_value])
-          key.failure("both profit and stop loss values required for BO orders")
+      # --------------------------------------------------
+      # BRACKET ORDER LOGIC
+      # --------------------------------------------------
+
+      rule(:product_type, :bo_profit_value, :bo_stop_loss_value) do
+        if (values[:product_type] == DhanHQ::Constants::ProductType::BO) && (!values[:bo_profit_value] || !values[:bo_stop_loss_value])
+          key.failure("both bo_profit_value and bo_stop_loss_value required for BO orders")
         end
       end
 
-      rule(:disclosed_quantity) do
-        key.failure("cannot exceed 30% of total quantity") if value && value > (values[:quantity] * 0.3)
+      rule(:product_type, :transaction_type, :price, :bo_profit_value, :bo_stop_loss_value) do
+        next unless values[:product_type] == DhanHQ::Constants::ProductType::BO
+        next unless values[:price] && values[:bo_profit_value] && values[:bo_stop_loss_value]
+
+        if values[:transaction_type] == DhanHQ::Constants::TransactionType::BUY
+          if values[:bo_stop_loss_value] >= values[:price]
+            key(:bo_stop_loss_value).failure("must be less than entry price for BUY BO")
+          end
+          if values[:bo_profit_value] <= values[:price]
+            key(:bo_profit_value).failure("must be greater than entry price for BUY BO")
+          end
+        elsif values[:transaction_type] == DhanHQ::Constants::TransactionType::SELL
+          if values[:bo_stop_loss_value] <= values[:price]
+            key(:bo_stop_loss_value).failure("must be greater than entry price for SELL BO")
+          end
+          if values[:bo_profit_value] >= values[:price]
+            key(:bo_profit_value).failure("must be less than entry price for SELL BO")
+          end
+        end
       end
 
-      # Modification specific rules (when extending)
-      rule(:leg_name) do
-        if values[:product_type] == "BO" && !%w[ENTRY_LEG TARGET_LEG STOP_LOSS_LEG].include?(value)
-          key.failure("invalid leg name for BO order")
+      # --------------------------------------------------
+      # DISCLOSED QUANTITY
+      # --------------------------------------------------
+
+      rule(:disclosed_quantity, :quantity) do
+        next unless values[:disclosed_quantity]
+
+        if values[:disclosed_quantity] > (values[:quantity] * 0.3)
+          key(:disclosed_quantity).failure("cannot exceed 30% of total quantity")
+        end
+      end
+
+      # --------------------------------------------------
+      # AMO VALIDATION
+      # --------------------------------------------------
+
+      rule(:after_market_order, :amo_time) do
+        if values[:after_market_order] == true && !values[:amo_time]
+          key(:amo_time).failure("must be present when after_market_order is true")
+        end
+      end
+
+      # --------------------------------------------------
+      # LOT SIZE ENFORCEMENT
+      # --------------------------------------------------
+
+      rule(:quantity) do
+        next unless instrument_meta
+        next unless instrument_meta[:lot_size]
+        next unless instrument_meta[:lot_size].positive?
+
+        lot = instrument_meta[:lot_size]
+
+        if value % lot != 0
+          key.failure("must be multiple of lot size #{lot}")
+        end
+      end
+
+      # --------------------------------------------------
+      # TICK SIZE ENFORCEMENT
+      # --------------------------------------------------
+
+      rule(:price) do
+        next unless instrument_meta
+        next unless instrument_meta[:tick_size]
+        next unless value
+
+        tick = instrument_meta[:tick_size]
+
+        remainder = ((value.to_f / tick) % 1).round(10)
+
+        if remainder != 0
+          key.failure("must align with tick size #{tick}")
+        end
+      end
+
+      rule(:trigger_price) do
+        next unless instrument_meta
+        next unless instrument_meta[:tick_size]
+        next unless value
+
+        tick = instrument_meta[:tick_size]
+
+        remainder = ((value.to_f / tick) % 1).round(10)
+
+        if remainder != 0
+          key.failure("must align with tick size #{tick}")
+        end
+      end
+
+      # --------------------------------------------------
+      # SEGMENT RESTRICTIONS
+      # --------------------------------------------------
+
+      rule(:exchange_segment, :product_type) do
+        next unless values[:exchange_segment] && values[:product_type]
+
+        segment = values[:exchange_segment]
+        product = values[:product_type]
+
+        if product == DhanHQ::Constants::ProductType::CNC && !%w[NSE_EQ BSE_EQ].include?(segment)
+          key(:product_type).failure("is only allowed for Equity segments")
+        end
+
+        if product == DhanHQ::Constants::ProductType::MARGIN && %w[NSE_EQ BSE_EQ].include?(segment)
+          key(:product_type).failure("is not allowed for Equity Cash segments")
+        end
+
+        # BO not allowed in some segments
+        if %w[NSE_CURRENCY BSE_CURRENCY].include?(segment) && product == DhanHQ::Constants::ProductType::BO
+          key(:product_type).failure("BO not allowed for currency segment")
+        end
+
+        # CO restrictions example
+        if segment == DhanHQ::Constants::ExchangeSegment::NSE_EQ && product == DhanHQ::Constants::ProductType::CO
+          key(:product_type).failure("CO not supported in NSE_EQ")
         end
       end
     end