DhanHQ 3.1.0 → 3.2.0

data/lib/DhanHQ/configuration.rb

@@ -41,6 +41,47 @@ module DhanHQ
     # Whether to use the sandbox environment.
     attr_accessor :sandbox
 
+    # When true, state-changing requests (order placement, modification,
+    # cancellation, position exits, trading controls) are validated and logged but
+    # never sent to the API — the client answers with a simulated response instead.
+    #
+    # Read-only requests still hit the API, so market data, the option chain,
+    # positions and holdings remain live. That makes dry-run usable for a full
+    # strategy rehearsal against real prices.
+    #
+    # Set via +DHAN_DRY_RUN=true+ or in {DhanHQ.configure}.
+    # @return [Boolean]
+    attr_accessor :dry_run
+
+    # Whether to auto-retry non-idempotent writes (order placement, modification,
+    # cancellation) after a transient failure — a 429, a 5xx, or a network timeout.
+    #
+    # Defaults to +false+, because the DhanHQ API has no idempotency key: a POST
+    # /v2/orders that times out may well have reached the exchange, and retrying it
+    # can place a second, duplicate order. With this off, the transient error is
+    # raised to the caller, who can reconcile using the correlation id (see
+    # {#auto_correlation_id} and +DhanHQ::Models::Order.find_by_correlation_id+)
+    # before deciding to resubmit.
+    #
+    # Read requests are always retried regardless of this setting.
+    #
+    # Set via +DHAN_RETRY_WRITES=true+ or in {DhanHQ.configure}.
+    # @return [Boolean]
+    attr_accessor :retry_non_idempotent_writes
+
+    # Whether to generate a +correlationId+ for order placements that do not carry
+    # one. The correlation id is the only way to answer "did my order actually go
+    # through?" after a timeout, via GET /v2/orders/external/{correlation-id}.
+    #
+    # Defaults to +false+ because it changes the request body, which would break
+    # callers matching recorded fixtures on the exact payload. Turn it on to get
+    # timeout-reconcilable orders for free. Only fills the field when absent; an
+    # explicit correlation id is always preserved.
+    #
+    # Set via +DHAN_AUTO_CORRELATION_ID=true+ or in {DhanHQ.configure}.
+    # @return [Boolean]
+    attr_accessor :auto_correlation_id
+
     # URL for the compact CSV format of instruments.
     # @return [String] URL for compact CSV.
     attr_accessor :compact_csv_url
@@ -124,6 +165,21 @@ module DhanHQ
       @sandbox == true
     end
 
+    # @return [Boolean] True when state-changing requests should be simulated.
+    def dry_run?
+      @dry_run == true
+    end
+
+    # @return [Boolean] True when non-idempotent writes may be auto-retried.
+    def retry_non_idempotent_writes?
+      @retry_non_idempotent_writes == true
+    end
+
+    # @return [Boolean] True when a correlation id should be generated for orders.
+    def auto_correlation_id?
+      @auto_correlation_id == true
+    end
+
     # Initializes a new configuration instance with default values.
     #
     # @example
@@ -133,7 +189,10 @@ module DhanHQ
     def initialize
       @client_id = ENV.fetch("DHAN_CLIENT_ID", nil)
       @access_token = ENV.fetch("DHAN_ACCESS_TOKEN", nil)
-      @sandbox        = ENV.fetch("DHAN_SANDBOX", "false").to_s.casecmp("true").zero?
+      @sandbox        = env_flag("DHAN_SANDBOX", default: false)
+      @dry_run        = env_flag("DHAN_DRY_RUN", default: false)
+      @retry_non_idempotent_writes = env_flag("DHAN_RETRY_WRITES", default: false)
+      @auto_correlation_id = env_flag("DHAN_AUTO_CORRELATION_ID", default: false)
       @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", nil)
@@ -144,5 +203,15 @@ module DhanHQ
       @partner_id     = ENV.fetch("DHAN_PARTNER_ID", nil)
       @partner_secret = ENV.fetch("DHAN_PARTNER_SECRET", nil)
     end
+
+    private
+
+    # Reads a boolean-ish environment variable, falling back to +default+ when unset.
+    def env_flag(name, default:)
+      raw = ENV.fetch(name, nil)
+      return default if raw.nil? || raw.to_s.strip.empty?
+
+      raw.to_s.casecmp("true").zero?
+    end
   end
 end

data/lib/DhanHQ/constants.rb

@@ -16,8 +16,14 @@ module DhanHQ
       MCX_COMM = "MCX_COMM"
       BSE_CURRENCY = "BSE_CURRENCY"
       BSE_FNO = "BSE_FNO"
+      # US / international equities, traded through the Global Stocks APIs
+      # (`/v2/globalstocks/*`). Deliberately excluded from {ALL} so it can never
+      # satisfy the domestic order contracts.
+      INX_EQ = "INX_EQ"
 
       ALL = [IDX_I, NSE_EQ, NSE_FNO, NSE_CURRENCY, NSE_COMM, BSE_EQ, MCX_COMM, BSE_CURRENCY, BSE_FNO].freeze
+      # Segments served by the Global Stocks APIs.
+      GLOBAL_ALL = [INX_EQ].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).
@@ -218,6 +224,64 @@ module DhanHQ
       ].freeze
     end
 
+    # Enumerations specific to the Global Stocks (US equities) APIs served under
+    # `/v2/globalstocks/*`. These orders carry no exchange segment, product type
+    # or validity — the domestic {ProductType}/{Validity} enums do not apply.
+    #
+    # @see https://dhanhq.co/docs/v2/ Global Stocks section
+    module GlobalStocks
+      # The only exchange segment currently supported by the Global Stocks feed.
+      EXCHANGE_SEGMENT = ExchangeSegment::INX_EQ
+      # Numeric exchange-segment code used in the binary WebSocket header.
+      EXCHANGE_SEGMENT_CODE = 14
+      # Maximum instruments accepted per Global Stocks feed subscription frame.
+      MAX_INSTRUMENTS_PER_REQUEST = 100
+      # Maximum concurrent subscriptions on a single Global Stocks connection.
+      MAX_SUBSCRIPTIONS_PER_CONNECTION = 5_000
+      # Maximum concurrent Global Stocks feed connections per client.
+      MAX_CONNECTIONS_PER_CLIENT = 5
+
+      # Order types accepted by POST /v2/globalstocks/orders. Adds +AMOUNT+
+      # (notional/dollar-value orders) on top of the domestic order types.
+      module OrderType
+        MARKET = "MARKET"
+        LIMIT = "LIMIT"
+        STOP_LOSS = "STOP_LOSS"
+        STOP_LOSS_MARKET = "STOP_LOSS_MARKET"
+        AMOUNT = "AMOUNT"
+
+        ALL = [MARKET, LIMIT, STOP_LOSS, STOP_LOSS_MARKET, AMOUNT].freeze
+      end
+
+      # Leg names accepted when modifying a Global Stocks super order.
+      module LegName
+        ENTRY_LEG = "ENTRY_LEG"
+        STOP_LOSS_LEG = "STOP_LOSS_LEG"
+        TARGET_LEG = "TARGET_LEG"
+        NA = "NA"
+
+        ALL = [ENTRY_LEG, STOP_LOSS_LEG, TARGET_LEG, NA].freeze
+      end
+
+      # Values returned by GET /v2/globalstocks/marketstatus.
+      module MarketStatus
+        OPEN = "open"
+        CLOSED = "closed"
+
+        ALL = [OPEN, CLOSED].freeze
+      end
+
+      # Message codes on the Global Stocks binary feed.
+      module MsgCode
+        TRADE = 1
+        PREV_CLOSE = 32
+        CIRCUIT_LIMIT = 33
+        FIFTY_TWO_WEEK = 36
+
+        ALL = [TRADE, PREV_CLOSE, CIRCUIT_LIMIT, FIFTY_TWO_WEEK].freeze
+      end
+    end
+
     # Comparison types for conditional trigger alerts.
     module ComparisonType
       TECHNICAL_WITH_VALUE = "TECHNICAL_WITH_VALUE"
@@ -399,6 +463,7 @@ module DhanHQ
       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"
+      WS_GLOBAL_STOCKS_FEED = "wss://global-stocks-api-feed.dhan.co"
       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"
@@ -424,6 +489,9 @@ module DhanHQ
     COMPARISON_TYPES = ComparisonType::ALL
     OPERATORS = Operator::ALL
     ALERT_CONDITION_SEGMENTS = ExchangeSegment::ALERT_CONDITION_ALL
+    GLOBAL_STOCKS_SEGMENTS = ExchangeSegment::GLOBAL_ALL
+    GLOBAL_STOCKS_ORDER_TYPES = GlobalStocks::OrderType::ALL
+    GLOBAL_STOCKS_LEG_NAMES = GlobalStocks::LegName::ALL
     ALERT_TIMEFRAMES = %w[DATE ONE_MIN FIVE_MIN FIFTEEN_MIN DAY].freeze
 
     # Exchange aliases used when building subscription payloads.
@@ -475,6 +543,7 @@ module DhanHQ
     # Injection is done in the client layer when building the payload.
     PAYLOAD_REQUIRES_DHAN_CLIENT_ID_PREFIXES = %w[
       /alerts/orders
+      /v2/alerts
       /v2/orders
       /v2/orders/iceberg
       /v2/orders/twap
@@ -485,6 +554,38 @@ module DhanHQ
       /v2/margincalculator
       /v2/killswitch
       /v2/ip
+      /v2/globalstocks
+    ].freeze
+
+    # Path prefixes whose non-GET requests change real account state — they place,
+    # modify or cancel orders, exit positions, or alter trading controls.
+    #
+    # Note that a POST is not automatically a mutation on this API: option chain,
+    # market feed, historical charts and the margin calculators are all read-only
+    # POSTs. Dry-run mode and non-idempotent retry protection consult this list so
+    # they act on real writes only and leave data fetches alone.
+    MUTATING_PATH_PREFIXES = %w[
+      /v2/orders
+      /v2/super/orders
+      /v2/forever
+      /v2/alerts
+      /v2/globalstocks/orders
+      /v2/positions
+      /v2/killswitch
+      /v2/pnlExit
+      /v2/edis
+      /v2/ip
+    ].freeze
+
+    # Subset of {MUTATING_PATH_PREFIXES} that create orders. A retried POST to one
+    # of these can produce a duplicate order, and dry-run mode answers these with a
+    # simulated order id so caller code paths still complete.
+    ORDER_PLACEMENT_PATH_PREFIXES = %w[
+      /v2/orders
+      /v2/super/orders
+      /v2/forever
+      /v2/alerts
+      /v2/globalstocks/orders
     ].freeze
 
     # Mapping of exchange and segment combinations to canonical exchange segment names.

data/lib/DhanHQ/contracts/expired_options_data_contract.rb

@@ -71,8 +71,7 @@ module DhanHQ
             from_date = Date.parse(values[:from_date])
             to_date = Date.parse(values[:to_date])
 
-            key.failure("from_date must be before to_date") if from_date >= to_date
-            key.failure("from_date must be a valid trading date (no weekend dates)") unless trading_day?(from_date)
+            key.failure("from_date must be before or equal to to_date") if from_date > to_date
 
             # Check if date range is not too large (max 31 days; to_date is non-inclusive)
             key.failure("date range cannot exceed 31 days") if (to_date - from_date).to_i > 31
@@ -101,13 +100,6 @@ module DhanHQ
           false
         end
       end
-
-      def trading_day?(date)
-        return false unless date.is_a?(Date)
-
-        # Sunday = 0, Saturday = 6; trading days are Monday (1) through Friday (5)
-        (1..5).cover?(date.wday)
-      end
     end
   end
 end

data/lib/DhanHQ/contracts/global_stocks_estimator_contract.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base_contract"
+
+module DhanHQ
+  module Contracts
+    # Validation contract shared by POST /v2/globalstocks/transEstimate
+    # (order charge estimate) and POST /v2/globalstocks/margincalculator.
+    #
+    # Both endpoints accept the same +InxEstimatorRequest+ body. The API documents
+    # +price+ and +quantity+ as strings on the wire; this contract validates them
+    # as numbers and the resource stringifies them before sending.
+    class GlobalStocksEstimatorContract < BaseContract
+      TRANSACTION_TYPES = DhanHQ::Constants::TransactionType::ALL
+
+      params do
+        required(:security_id).filled(:string, max_size?: 50)
+        required(:transaction_type).filled(:string, included_in?: TRANSACTION_TYPES)
+        required(:price).filled(:float, gteq?: 0)
+        required(:quantity).filled(:float, gt?: 0)
+      end
+
+      rule(:price) do
+        key.failure("must be a finite number") if value.is_a?(Float) && (value.nan? || value.infinite?)
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/global_stocks_modify_order_contract.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "global_stocks_order_contract"
+
+module DhanHQ
+  module Contracts
+    # Validation contract for PUT /v2/globalstocks/orders/{order-id}.
+    class GlobalStocksModifyOrderContract < GlobalStocksOrderContract
+      params do
+        required(:order_id).filled(:string)
+        required(:transaction_type).filled(:string, included_in?: TRANSACTION_TYPES)
+        required(:order_type).filled(:string, included_in?: ORDER_TYPES)
+        required(:security_id).filled(:string, max_size?: 50)
+
+        optional(:quantity).maybe(:float, gt?: 0)
+        optional(:price).maybe(:float, gteq?: 0)
+        optional(:leg_name).maybe(:string, included_in?: LEG_NAMES)
+        optional(:dhan_client_id).maybe(:string)
+      end
+
+      rule(:order_type, :price) do
+        key(:price).failure("must be greater than 0 for LIMIT orders") if PRICED_ORDER_TYPES.include?(values[:order_type]) && !values[:price]&.positive?
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/global_stocks_order_contract.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+require_relative "base_contract"
+
+module DhanHQ
+  module Contracts
+    # Base contract shared by the Global Stocks (US equities) order contracts.
+    #
+    # Global Stocks orders differ from domestic orders in three ways that make the
+    # domestic {OrderContract} unusable here:
+    #
+    # 1. There is no +exchange_segment+, +product_type+ or +validity+ field.
+    # 2. +quantity+ is a float — fractional shares are supported.
+    # 3. +order_type+ adds +AMOUNT+, a notional (dollar-value) order which carries
+    #    an +amount+ instead of a +quantity+.
+    #
+    # @see https://dhanhq.co/docs/v2/ Global Stocks section
+    class GlobalStocksOrderContract < BaseContract
+      TRANSACTION_TYPES = DhanHQ::Constants::TransactionType::ALL
+      ORDER_TYPES       = DhanHQ::Constants::GlobalStocks::OrderType::ALL
+      LEG_NAMES         = DhanHQ::Constants::GlobalStocks::LegName::ALL
+
+      # Order types that require a limit price.
+      PRICED_ORDER_TYPES = [DhanHQ::Constants::GlobalStocks::OrderType::LIMIT].freeze
+      # Order types that require a trigger price.
+      TRIGGERED_ORDER_TYPES = [
+        DhanHQ::Constants::GlobalStocks::OrderType::STOP_LOSS,
+        DhanHQ::Constants::GlobalStocks::OrderType::STOP_LOSS_MARKET
+      ].freeze
+    end
+  end
+end

data/lib/DhanHQ/contracts/global_stocks_place_order_contract.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "global_stocks_order_contract"
+
+module DhanHQ
+  module Contracts
+    # Validation contract for POST /v2/globalstocks/orders.
+    #
+    # @example
+    #   DhanHQ::Contracts::GlobalStocksPlaceOrderContract.new.call(
+    #     transaction_type: "BUY",
+    #     order_type: "LIMIT",
+    #     security_id: "AAPL",
+    #     quantity: 1.0,
+    #     price: 180.0
+    #   )
+    class GlobalStocksPlaceOrderContract < GlobalStocksOrderContract
+      params do
+        required(:transaction_type).filled(:string, included_in?: TRANSACTION_TYPES)
+        required(:order_type).filled(:string, included_in?: ORDER_TYPES)
+        required(:security_id).filled(:string, max_size?: 50)
+
+        optional(:correlation_id).maybe(:string, max_size?: 30, format?: /\A[a-zA-Z0-9 _-]*\z/)
+        optional(:quantity).maybe(:float, gt?: 0)
+        optional(:price).maybe(:float, gteq?: 0)
+        optional(:trigger_price).maybe(:float, gt?: 0)
+        optional(:stop_loss_price).maybe(:float, gt?: 0)
+        optional(:target_price).maybe(:float, gt?: 0)
+        optional(:amount).maybe(:float, gt?: 0)
+        optional(:after_market_order).maybe(:bool)
+        optional(:dhan_client_id).maybe(:string)
+      end
+
+      # AMOUNT orders are notional: they carry `amount` instead of `quantity`.
+      # Every other order type needs a quantity.
+      rule(:order_type, :quantity, :amount) do
+        if values[:order_type] == DhanHQ::Constants::GlobalStocks::OrderType::AMOUNT
+          key(:amount).failure("must be present for AMOUNT orders") unless values[:amount]
+        elsif !values[:quantity]
+          key(:quantity).failure("must be present unless order_type is AMOUNT")
+        end
+      end
+
+      rule(:order_type, :price) do
+        price = values[:price]
+
+        key(:price).failure("must be greater than 0 for LIMIT orders") if PRICED_ORDER_TYPES.include?(values[:order_type]) && !price&.positive?
+        key(:price).failure("must be a finite number") if price.is_a?(Float) && (price.nan? || price.infinite?)
+      end
+
+      rule(:order_type, :trigger_price) do
+        key(:trigger_price).failure("must be present for STOP_LOSS orders") if TRIGGERED_ORDER_TYPES.include?(values[:order_type]) && !values[:trigger_price]
+      end
+
+      # Mirrors the domestic super-order relationship checks: a BUY exits above
+      # entry and stops out below it, and vice versa for a SELL.
+      rule(:transaction_type, :price, :target_price, :stop_loss_price) do
+        price = values[:price]
+        next unless price&.positive?
+
+        target = values[:target_price]
+        stop = values[:stop_loss_price]
+
+        case values[:transaction_type]
+        when DhanHQ::Constants::TransactionType::BUY
+          key(:target_price).failure("must be greater than price for BUY orders") if target && target <= price
+          key(:stop_loss_price).failure("must be less than price for BUY orders") if stop && stop >= price
+        when DhanHQ::Constants::TransactionType::SELL
+          key(:target_price).failure("must be less than price for SELL orders") if target && target >= price
+          key(:stop_loss_price).failure("must be greater than price for SELL orders") if stop && stop <= price
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/historical_data_contract.rb

@@ -18,36 +18,16 @@ module DhanHQ
         optional(:oi).maybe(:bool)
       end
 
-      rule(:from_date) do
-        next unless value.is_a?(String) && value.match?(/\A\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2})?\z/)
-
-        # 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}( \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 = 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
+        key.failure("from_date must be before or equal to to_date") if from_date > to_date
       rescue Date::Error
         key.failure("invalid date format")
       end
-
-      private
-
-      def trading_day?(date)
-        return false unless date.is_a?(Date)
-
-        (1..5).cover?(date.wday)
-      end
     end
   end
 end

data/lib/DhanHQ/contracts/multi_order_contract.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+require_relative "base_contract"
+
+module DhanHQ
+  module Contracts
+    # Validation contract for POST /v2/alerts/multi/orders (basket orders).
+    #
+    # A multi order places up to {MAX_ORDERS} unconditional orders in a single
+    # request. Each leg carries a +sequence+ that identifies it in the response.
+    class MultiOrderContract < BaseContract
+      # Maximum legs the API accepts in one basket.
+      MAX_ORDERS = 15
+
+      TRANSACTION_TYPES = DhanHQ::Constants::TransactionType::ALL
+      EXCHANGE_SEGMENTS = DhanHQ::Constants::ExchangeSegment::ALL
+      PRODUCT_TYPES     = DhanHQ::Constants::ProductType::MARGIN_CALC_ALL
+      ORDER_TYPES       = DhanHQ::Constants::OrderType::ALL
+      VALIDITY_TYPES    = DhanHQ::Constants::Validity::ALL
+      AMO_TIMES         = DhanHQ::Constants::AmoTime::ALL
+
+      params do
+        optional(:dhan_client_id).maybe(:string)
+
+        required(:orders).array(:hash) do
+          required(:sequence).filled(:string)
+          required(:transaction_type).filled(:string, included_in?: TRANSACTION_TYPES)
+          required(:exchange_segment).filled(: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)
+          optional(:quantity).maybe(:integer, gt?: 0)
+          optional(:price).maybe(:float, gt?: 0)
+          optional(:trigger_price).maybe(:float, gt?: 0)
+          optional(:disclosed_quantity).maybe(:integer, gteq?: 0)
+          optional(:correlation_id).maybe(:string, max_size?: 30)
+          optional(:after_market_order).maybe(:bool)
+          optional(:amo_time).maybe(:string, included_in?: AMO_TIMES)
+        end
+      end
+
+      rule(:orders) do
+        key.failure("must contain at least one order") if value.empty?
+        key.failure("cannot contain more than #{MAX_ORDERS} orders") if value.size > MAX_ORDERS
+
+        sequences = value.map { |order| order[:sequence] }
+        key.failure("sequence values must be unique") if sequences.uniq.size != sequences.size
+      end
+
+      # Order types that require a trigger price on each leg.
+      TRIGGERED_ORDER_TYPES = [
+        DhanHQ::Constants::OrderType::STOP_LOSS,
+        DhanHQ::Constants::OrderType::STOP_LOSS_MARKET
+      ].freeze
+
+      # Per-leg price/trigger consistency, mirroring the single-order contract.
+      rule(:orders) do
+        value.each_with_index do |order, index|
+          type = order[:order_type]
+
+          key([:orders, index, :price]).failure("must be present for LIMIT orders") if type == DhanHQ::Constants::OrderType::LIMIT && !order[:price]
+          key([:orders, index, :price]).failure("must not be provided for MARKET orders") if type == DhanHQ::Constants::OrderType::MARKET && order[:price]
+
+          next unless TRIGGERED_ORDER_TYPES.include?(type) && !order[:trigger_price]
+
+          key([:orders, index, :trigger_price]).failure("must be present for STOP_LOSS orders")
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/trade_history_contract.rb

@@ -14,9 +14,6 @@ module DhanHQ
 
       rule(:from_date) do
         key.failure("must be in YYYY-MM-DD format (e.g., 2024-01-15)") unless valid_date_format?(value)
-        next unless valid_date_format?(value)
-
-        key.failure("must be a valid trading date (no weekend dates)") unless trading_day?(Date.parse(value))
       end
 
       rule(:to_date) do
@@ -28,7 +25,7 @@ module DhanHQ
         to = values[:to_date]
         next unless valid_date_format?(from) && valid_date_format?(to)
 
-        key.failure("from_date must be before to_date") if Date.parse(from) >= Date.parse(to)
+        key.failure("from_date must be before or equal to to_date") if Date.parse(from) > Date.parse(to)
       rescue Date::Error
         key.failure("invalid date format")
       end
@@ -43,10 +40,6 @@ module DhanHQ
       rescue Date::Error
         false
       end
-
-      def trading_day?(date)
-        date.is_a?(Date) && (1..5).cover?(date.wday)
-      end
     end
   end
 end

data/lib/DhanHQ/dry_run/ledger.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module DhanHQ
+  module DryRun
+    # Remembers the orders a dry run pretended to place, so a follow-up read for one
+    # of those simulated ids can be answered locally.
+    #
+    # This exists because the high-level models re-fetch after placing:
+    # `Models::Order.place` and `GlobalStocks::Order.place` both call `find(order_id)`
+    # to return the complete record. Without a ledger that GET would leave the process
+    # carrying a `DRYRUN-…` id to the live API, which is both a real network call and a
+    # guaranteed miss — so dry run would only have worked for direct
+    # {DhanHQ::Client#request} calls, not the API people actually use.
+    #
+    # Entries are per-process and capped; a long rehearsal evicts its oldest records
+    # rather than growing without bound.
+    class Ledger
+      # Maximum simulated orders retained before the oldest are evicted.
+      MAX_ENTRIES = 500
+
+      def initialize(max_entries: MAX_ENTRIES)
+        @max_entries = max_entries
+        @records = {}
+        @mutex = Mutex.new
+      end
+
+      # Process-wide ledger used by {DhanHQ::DryRun::Simulator}.
+      #
+      # @return [Ledger]
+      def self.instance
+        @instance ||= new
+      end
+
+      # Records a simulated order.
+      #
+      # @param order_id [String] The simulated order id
+      # @param record [Hash] The response to replay for reads of that id
+      # @return [Hash] The stored record
+      def record(order_id, record)
+        @mutex.synchronize do
+          @records.delete(order_id)
+          @records[order_id] = record
+          @records.shift while @records.size > @max_entries
+          record
+        end
+      end
+
+      # Fetches a previously simulated order.
+      #
+      # @param order_id [String]
+      # @return [Hash, nil] nil when the id was never simulated in this process
+      def fetch(order_id)
+        @mutex.synchronize { @records[order_id] }
+      end
+
+      # @return [Integer] Number of retained records
+      def size
+        @mutex.synchronize { @records.size }
+      end
+
+      # Drops every retained record. Intended for test isolation.
+      #
+      # @return [void]
+      def clear
+        @mutex.synchronize { @records.clear }
+      end
+    end
+  end
+end