DhanHQ 2.1.0

data/lib/DhanHQ/constants.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  # Enumerations and helper lookups used across the REST and WebSocket clients.
+  module Constants
+    # Valid transaction directions accepted by order placement APIs.
+    TRANSACTION_TYPES = %w[BUY SELL].freeze
+
+    # Supported exchange segments for security lookups and subscription APIs.
+    EXCHANGE_SEGMENTS = %w[
+      NSE_EQ
+      NSE_FNO
+      NSE_CURRENCY
+      BSE_EQ
+      BSE_FNO
+      BSE_CURRENCY
+      MCX_COMM
+      IDX_I
+    ].freeze
+
+    # Security instrument kinds returned in instrument master downloads.
+    INSTRUMENTS = %w[
+      INDEX
+      FUTIDX
+      OPTIDX
+      EQUITY
+      FUTSTK
+      OPTSTK
+      FUTCOM
+      OPTFUT
+      FUTCUR
+      OPTCUR
+    ].freeze
+
+    # Product types that can be used while placing or modifying orders.
+    PRODUCT_TYPES = %w[
+      CNC
+      INTRADAY
+      MARGIN
+      MTF
+      CO
+      BO
+    ].freeze
+
+    # Order execution types supported by the platform.
+    ORDER_TYPES = %w[
+      LIMIT
+      MARKET
+      STOP_LOSS
+      STOP_LOSS_MARKET
+    ].freeze
+
+    # Order validity flags supported by the trading APIs.
+    VALIDITY_TYPES = %w[DAY IOC].freeze
+
+    # Permitted after-market order submission windows.
+    AMO_TIMINGS = %w[
+      OPEN
+      OPEN_30
+      OPEN_60
+      PRE_OPEN
+    ].freeze
+
+    # Status values returned when querying order lifecycle events.
+    ORDER_STATUSES = %w[
+      TRANSIT
+      PENDING
+      REJECTED
+      CANCELLED
+      PART_TRADED
+      TRADED
+      EXPIRED
+      MODIFIED
+      TRIGGERED
+    ].freeze
+
+    # Exchange aliases used when building subscription payloads.
+    NSE = "NSE_EQ"
+    # Bombay Stock Exchange equities segment alias.
+    BSE = "BSE_EQ"
+    # Currency segment alias.
+    CUR = "NSE_CURRENCY"
+    # Multi Commodity Exchange segment alias.
+    MCX = "MCX_COMM"
+    # F&O segment alias.
+    FNO = "NSE_FNO"
+    # National Stock Exchange futures & options segment alias.
+    NSE_FNO = "NSE_FNO"
+    # Bombay Stock Exchange futures & options segment alias.
+    BSE_FNO = "BSE_FNO"
+    # Broad index segment alias.
+    INDEX = "IDX_I"
+
+    # Segments that support option instruments.
+    OPTION_SEGMENTS = [NSE, BSE, CUR, MCX, FNO, NSE_FNO, BSE_FNO, INDEX].freeze
+
+    # Canonical buy transaction label.
+    BUY = "BUY"
+    # Canonical sell transaction label.
+    SELL = "SELL"
+
+    # Cash-and-carry product identifier.
+    CNC = "CNC"
+    # Intraday margin product identifier.
+    INTRA = "INTRADAY"
+    # Carry-forward margin product identifier.
+    MARGIN = "MARGIN"
+    # Cover order product identifier.
+    CO = "CO"
+    # Bracket order product identifier.
+    BO = "BO"
+    # Margin trading funding identifier.
+    MTF = "MTF"
+
+    # Limit price order type.
+    LIMIT = "LIMIT"
+    # Market order type.
+    MARKET = "MARKET"
+    # Stop-loss limit order type.
+    SL = "STOP_LOSS"
+    # Stop-loss market order type.
+    SLM = "STOP_LOSS_MARKET"
+
+    # Good-for-day validity flag.
+    DAY = "DAY"
+    # Immediate-or-cancel validity flag.
+    IOC = "IOC"
+
+    # Download URL for the compact instrument master CSV.
+    COMPACT_CSV_URL = "https://images.dhan.co/api-data/api-scrip-master.csv"
+    # Download URL for the detailed instrument master CSV.
+    DETAILED_CSV_URL = "https://images.dhan.co/api-data/api-scrip-master-detailed.csv"
+
+    # API routes that require a `client-id` header in addition to the access token.
+    DATA_API_PATHS = %w[
+      /v2/marketfeed/ltp
+      /v2/marketfeed/ohlc
+      /v2/marketfeed/quote
+      /v2/optionchain
+      /v2/optionchain/expirylist
+    ].freeze
+
+    # Mapping of DhanHQ error codes to SDK error classes for consistent exception handling.
+    DHAN_ERROR_MAPPING = {
+      "DH-901" => DhanHQ::InvalidAuthenticationError,
+      "DH-902" => DhanHQ::InvalidAccessError,
+      "DH-903" => DhanHQ::UserAccountError,
+      "DH-904" => DhanHQ::RateLimitError,
+      "DH-905" => DhanHQ::InputExceptionError,
+      "DH-906" => DhanHQ::OrderError,
+      "DH-907" => DhanHQ::DataError,
+      "DH-908" => DhanHQ::InternalServerError,
+      "DH-1111" => DhanHQ::NoHoldingsError,
+      "DH-909" => DhanHQ::NetworkError,
+      "DH-910" => DhanHQ::OtherError,
+      "800" => DhanHQ::InternalServerError,
+      "804" => DhanHQ::Error, # Too many instruments
+      "805" => DhanHQ::RateLimitError, # Too many requests
+      "806" => DhanHQ::DataError, # Data API not subscribed
+      "807" => DhanHQ::InvalidTokenError, # Token expired
+      "808" => DhanHQ::AuthenticationFailedError, # Auth failed
+      "809" => DhanHQ::InvalidTokenError, # Invalid token
+      "810" => DhanHQ::InvalidClientIDError, # Invalid Client ID
+      "811" => DhanHQ::InvalidRequestError,  # Invalid expiry date
+      "812" => DhanHQ::InvalidRequestError,  # Invalid date format
+      "813" => DhanHQ::InvalidRequestError,  # Invalid security ID
+      "814" => DhanHQ::InvalidRequestError # Invalid request
+    }.freeze
+  end
+end

data/lib/DhanHQ/contracts/base_contract.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+require_relative "../constants"
+
+module DhanHQ
+  # Namespace housing Dry::Validation contracts for request payload validation.
+  module Contracts
+    # Base contract that includes shared logic and constants.
+    class BaseContract < Dry::Validation::Contract
+      # Include constants to make them accessible in all derived contracts
+      include DhanHQ::Constants
+    end
+  end
+end

data/lib/DhanHQ/contracts/historical_data_contract.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates payloads for the historical data endpoints.
+    class HistoricalDataContract < Dry::Validation::Contract
+      include DhanHQ::Constants
+
+      params do
+        # Common required fields
+        required(:security_id).filled(:string)
+        required(:exchange_segment).filled(:string, included_in?: EXCHANGE_SEGMENTS)
+        required(:instrument).filled(:string, included_in?: INSTRUMENTS)
+
+        # 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])
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/margin_calculator_contract.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates requests sent to the margin calculator endpoint.
+    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(:quantity).filled(:integer, gt?: 0)
+        required(:productType).filled(:string, included_in?: %w[CNC INTRADAY MARGIN MTF CO BO])
+        required(:securityId).filled(:string)
+        required(:price).filled(:float, gt?: 0)
+        optional(:triggerPrice).maybe(:float)
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/modify_order_contract copy.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validation contract for modifying an existing order via Dhanhq's API.
+    #
+    # This contract validates input parameters for the Modify Order API,
+    # ensuring that all required fields are provided and optional fields follow
+    # the correct constraints. It also applies custom validation rules based on
+    # the type of order.
+    #
+    # Example usage:
+    #   contract = Dhanhq::Contracts::ModifyOrderContract.new
+    #   result = contract.call(
+    #     dhanClientId: "123456",
+    #     orderId: "1001",
+    #     orderType: "STOP_LOSS",
+    #     legName: "ENTRY_LEG",
+    #     quantity: 10,
+    #     price: 150.0,
+    #     triggerPrice: 140.0,
+    #     validity: "DAY"
+    #   )
+    #   result.success? # => true or false
+    #
+    # @see https://dhanhq.co/docs/v2/ Dhanhq API Documentation
+    class ModifyOrderContract < BaseContract
+      # Parameters and validation rules for the Modify Order request.
+      #
+      # @!attribute [r] orderId
+      #   @return [String] Required. Unique identifier for the order to be modified.
+      # @!attribute [r] orderType
+      #   @return [String] Required. Type of the order.
+      #     Must be one of: LIMIT, MARKET, STOP_LOSS, STOP_LOSS_MARKET.
+      # @!attribute [r] legName
+      #   @return [String] Optional. Leg name for complex orders.
+      #     Must be one of: ENTRY_LEG, TARGET_LEG, STOP_LOSS_LEG, NA.
+      # @!attribute [r] quantity
+      #   @return [Integer] Required. Quantity to be modified, must be greater than 0.
+      # @!attribute [r] price
+      #   @return [Float] Optional. Price to be modified, must be greater than 0 if provided.
+      # @!attribute [r] disclosedQuantity
+      #   @return [Integer] Optional. Disclosed quantity, must be >= 0 if provided.
+      # @!attribute [r] triggerPrice
+      #   @return [Float] Optional. Trigger price for stop-loss orders, must be greater than 0 if provided.
+      # @!attribute [r] validity
+      #   @return [String] Required. Validity of the order.
+      #     Must be one of: DAY, IOC, GTC, GTD.
+      params do
+        required(:orderId).filled(:string)
+        required(:orderType).filled(:string, included_in?: %w[LIMIT MARKET STOP_LOSS STOP_LOSS_MARKET])
+        optional(:legName).maybe(:string, included_in?: %w[ENTRY_LEG TARGET_LEG STOP_LOSS_LEG NA])
+        required(:quantity).filled(:integer, gt?: 0)
+        optional(:price).maybe(:float, gt?: 0)
+        optional(:disclosedQuantity).maybe(:integer, gteq?: 0)
+        optional(:triggerPrice).maybe(:float, gt?: 0)
+        required(:validity).filled(:string, included_in?: %w[DAY IOC GTC GTD])
+      end
+
+      # Custom validation to ensure a trigger price is provided for stop-loss orders.
+      #
+      # @example Invalid stop-loss order:
+      #   orderType: "STOP_LOSS", triggerPrice: nil
+      #   => Adds failure message "is required for orderType STOP_LOSS or STOP_LOSS_MARKET".
+      #
+      # @param triggerPrice [Float] The price at which the order will be triggered.
+      # @param orderType [String] The type of the order.
+      rule(:triggerPrice, :orderType) do
+        if values[:orderType].start_with?("STOP_LOSS") && !values[:triggerPrice]
+          key(:triggerPrice).failure("is required for orderType STOP_LOSS or STOP_LOSS_MARKET")
+        end
+      end
+
+      # Custom validation to ensure a leg name is provided for CO or BO order types.
+      #
+      # @example Invalid CO order:
+      #   orderType: "CO", legName: nil
+      #   => Adds failure message "is required for orderType CO or BO".
+      #
+      # @param legName [String] The leg name of the order.
+      # @param orderType [String] The type of the order.
+      rule(:legName, :orderType) do
+        if %w[CO BO].include?(values[:orderType]) && !values[:legName]
+          key(:legName).failure("is required for orderType CO or BO")
+        end
+      end
+
+      # Custom validation to ensure the price is valid if provided.
+      #
+      # @example Invalid price:
+      #   price: 0
+      #   => Adds failure message "must be greater than 0 if provided".
+      #
+      # @param price [Float] The price of the order.
+      rule(:price) do
+        key(:price).failure("must be greater than 0 if provided") if values[:price].nil? || values[:price] <= 0
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/modify_order_contract.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    class ModifyOrderContract < Dry::Validation::Contract
+      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])
+      end
+
+      rule(:quantity) do
+        key.failure("must be provided if modifying quantity") if value.nil? && values[:price].nil?
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/option_chain_contract.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "base_contract"
+
+module DhanHQ
+  module Contracts
+    # **Validation contract for fetching option chain data**
+    #
+    # Validates request parameters for fetching option chains & expiry lists.
+    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(: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}$/)
+
+        # 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")
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/order_contract.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# lib/dhan_hq/contracts/order_contract.rb
+require "dry-validation"
+
+module DhanHQ
+  module Contracts
+    # Shared contract used to validate place and modify order payloads.
+    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
+
+      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)
+        required(:order_type).filled(:string, included_in?: ORDER_TYPES)
+        required(:validity).filled(:string, included_in?: VALIDITY_TYPES)
+        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(: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
+      end
+
+      # Conditional validation rules
+      rule(:price) do
+        key.failure("must be present for LIMIT orders") if values[:order_type] == "LIMIT" && !value
+      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")
+        end
+      end
+
+      rule(:amo_time) do
+        key.failure("must be present for after market orders") if values[:after_market_order] == true && !value
+      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")
+        end
+      end
+
+      rule(:disclosed_quantity) do
+        key.failure("cannot exceed 30% of total quantity") if value && value > (values[:quantity] * 0.3)
+      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")
+        end
+      end
+    end
+
+    # Contract enforcing additional requirements for new order placement.
+    class PlaceOrderContract < OrderContract
+      # Additional placement specific rules
+      rule(:after_market_order) do
+        key.failure("amo_time required for after market orders") if value == true && !values[:amo_time]
+      end
+    end
+
+    # Contract extending {OrderContract} for order modification payloads.
+    class ModifyOrderContract < OrderContract
+      # Modification specific requirements
+      params do
+        required(:order_id).filled(:string)
+        optional(:quantity).maybe(:integer, gt?: 0)
+      end
+
+      rule do
+        if !values[:price] && !values[:quantity] && !values[:trigger_price]
+          key.failure("at least one modification field required")
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/place_order_contract.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validation contract for placing an order via Dhanhq's API.
+    #
+    # This contract validates the parameters required to place an order,
+    # ensuring the correctness of inputs based on API requirements. It includes:
+    # - Mandatory fields for order placement.
+    # - Conditional validation for optional fields based on provided values.
+    # - Validation of enumerated values using constants for consistency.
+    #
+    # Example usage:
+    #   contract = Dhanhq::Contracts::PlaceOrderContract.new
+    #   result = contract.call(
+    #     dhanClientId: "123456",
+    #     transaction_type: "BUY",
+    #     exchange_segment: "NSE_EQ",
+    #     product_type: "CNC",
+    #     order_type: "LIMIT",
+    #     validity: "DAY",
+    #     security_id: "1001",
+    #     quantity: 10,
+    #     price: 150.0
+    #   )
+    #   result.success? # => true or false
+    #
+    # @see https://dhanhq.co/docs/v2/ Dhanhq API Documentation
+    class PlaceOrderContract < BaseContract
+      # Parameters and validation rules for the place order request.
+      #
+      # @!attribute [r] correlation_id
+      #   @return [String] Optional. Identifier for tracking, max length 25 characters.
+      # @!attribute [r] transaction_type
+      #   @return [String] Required. BUY or SELL.
+      # @!attribute [r] exchange_segment
+      #   @return [String] Required. Exchange segment for the order.
+      #     Must be one of: `EXCHANGE_SEGMENTS`.
+      # @!attribute [r] product_type
+      #   @return [String] Required. Product type for the order.
+      #     Must be one of: `PRODUCT_TYPES`.
+      # @!attribute [r] order_type
+      #   @return [String] Required. Type of order.
+      #     Must be one of: `ORDER_TYPES`.
+      # @!attribute [r] validity
+      #   @return [String] Required. Validity of the order.
+      #     Must be one of: DAY, IOC.
+      # @!attribute [r] trading_symbol
+      #   @return [String] Optional. Trading symbol of the instrument.
+      # @!attribute [r] security_id
+      #   @return [String] Required. Security identifier for the order.
+      # @!attribute [r] quantity
+      #   @return [Integer] Required. Quantity of the order, must be greater than 0.
+      # @!attribute [r] disclosed_quantity
+      #   @return [Integer] Optional. Disclosed quantity, must be >= 0 if provided.
+      # @!attribute [r] price
+      #   @return [Float] Optional. Price for the order, must be > 0 if provided.
+      # @!attribute [r] trigger_price
+      #   @return [Float] Optional. Trigger price for stop-loss orders, must be > 0 if provided.
+      # @!attribute [r] after_market_order
+      #   @return [Boolean] Optional. Indicates if this is an after-market order.
+      # @!attribute [r] amo_time
+      #   @return [String] Optional. Time for after-market orders. Must be one of: OPEN, OPEN_30, OPEN_60.
+      # @!attribute [r] bo_profit_value
+      #   @return [Float] Optional. Profit value for Bracket Orders, must be > 0 if provided.
+      # @!attribute [r] bo_stop_loss_value
+      #   @return [Float] Optional. Stop-loss value for Bracket Orders, must be > 0 if provided.
+      # @!attribute [r] drv_expiry_date
+      #   @return [String] Optional. Expiry date for derivative contracts.
+      # @!attribute [r] drv_option_type
+      #   @return [String] Optional. Option type for derivatives, must be one of: CALL, PUT, NA.
+      # @!attribute [r] drv_strike_price
+      #   @return [Float] Optional. Strike price for options, must be > 0 if provided.
+      params 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(:validity).filled(:string, included_in?: VALIDITY_TYPES)
+        required(:security_id).filled(:string)
+        required(:quantity).filled(:integer, gt?: 0)
+        optional(:disclosed_quantity).maybe(:integer, gteq?: 0)
+        optional(:trading_symbol).maybe(:string)
+        optional(:correlation_id).maybe(:string, max_size?: 25)
+        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?: %w[OPEN OPEN_30 OPEN_60])
+        optional(:bo_profit_value).maybe(:float, gt?: 0)
+        optional(:bo_stop_loss_value).maybe(:float, gt?: 0)
+        optional(:drv_expiry_date).maybe(:string)
+        optional(:drv_option_type).maybe(:string, included_in?: %w[CALL PUT NA])
+        optional(:drv_strike_price).maybe(:float, gt?: 0)
+      end
+
+      # Custom validation for trigger price when the order type is STOP_LOSS or STOP_LOSS_MARKET.
+      rule(:trigger_price, :order_type) do
+        if values[:order_type] =~ /^STOP_LOSS/ && !values[:trigger_price]
+          key(:trigger_price).failure("is required for order_type STOP_LOSS or STOP_LOSS_MARKET")
+        end
+      end
+
+      # Custom validation for AMO time when the order is marked as after-market.
+      rule(:after_market_order, :amo_time) do
+        if values[:after_market_order] == true && !values[:amo_time]
+          key(:amo_time).failure("is required when after_market_order is true")
+        end
+      end
+
+      # Custom validation for Bracket Order (BO) fields.
+      rule(:bo_profit_value, :bo_stop_loss_value, :product_type) do
+        if values[:product_type] == "BO" && (!values[:bo_profit_value] || !values[:bo_stop_loss_value])
+          key(:bo_profit_value).failure("is required for Bracket Orders")
+          key(:bo_stop_loss_value).failure("is required for Bracket Orders")
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/position_conversion_contract.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates requests for converting positions between product types.
+    class PositionConversionContract < BaseContract
+      params do
+        required(:dhanClientId).filled(:string)
+        required(:fromProductType).filled(:string, included_in?: PRODUCT_TYPES)
+        required(:exchangeSegment).filled(:string, included_in?: EXCHANGE_SEGMENTS)
+        required(:positionType).filled(:string, included_in?: %w[LONG SHORT CLOSED])
+        required(:securityId).filled(:string)
+        required(:convertQty).filled(:integer, gt?: 0)
+        required(:toProductType).filled(:string, included_in?: PRODUCT_TYPES)
+      end
+
+      rule(:toProductType, :fromProductType) do
+        next unless values[:toProductType] == values[:fromProductType]
+
+        key(:toProductType).failure("must be different from fromProductType")
+      end
+    end
+  end
+end