DhanHQ 3.0.0 → 3.0.1

data/lib/DhanHQ/models/position.rb

@@ -44,6 +44,72 @@ module DhanHQ
                  :day_sell_value, :drv_expiry_date, :drv_option_type, :drv_strike_price,
                  :cross_currency
 
+      # Returns a concise prompt-friendly summary of the position.
+      def to_prompt
+        parts = [
+          "#{position_type} #{net_qty}x #{trading_symbol || security_id}",
+          "on #{exchange_segment}/#{product_type}"
+        ]
+        parts << "buy_avg=#{buy_avg}" if buy_avg&.positive?
+        parts << "sell_avg=#{sell_avg}" if sell_avg&.positive?
+        parts << "realized_pnl=#{realized_profit}" if realized_profit
+        parts << "unrealized_pnl=#{unrealized_profit}" if unrealized_profit
+        parts << "expiry=#{drv_expiry_date}" if drv_expiry_date
+        parts << "strike=#{drv_strike_price}" if drv_strike_price&.positive?
+        parts << "type=#{drv_option_type}" if drv_option_type
+        parts.join(", ")
+      end
+
+      # Returns true if this is a long position.
+      def long?
+        position_type == DhanHQ::Constants::PositionType::LONG
+      end
+
+      # Returns true if this is a short position.
+      def short?
+        position_type == DhanHQ::Constants::PositionType::SHORT
+      end
+
+      # Returns true if this position is closed.
+      def closed?
+        position_type == DhanHQ::Constants::OrderStatus::CLOSED || net_qty.to_i.zero?
+      end
+
+      # Returns true if this position has an open quantity.
+      def open?
+        !closed? && net_qty.to_i != 0
+      end
+
+      # Returns true if this position is profitable (unrealized).
+      def profitable?
+        unrealized_profit.to_f.positive?
+      end
+
+      # Returns true if this position is in loss (unrealized).
+      def in_loss?
+        unrealized_profit.to_f.negative?
+      end
+
+      # Returns the total unrealized P&L including realized.
+      def total_pnl
+        realized_profit.to_f + unrealized_profit.to_f
+      end
+
+      # Returns true if this is an F&O position.
+      def derivatives?
+        drv_expiry_date.present? || drv_strike_price.to_f.positive?
+      end
+
+      # Returns true if this is an options position.
+      def options?
+        derivatives? && drv_option_type.present?
+      end
+
+      # Returns true if this is a futures position.
+      def futures?
+        derivatives? && drv_option_type.nil?
+      end
+
       class << self
         ##
         # Provides a shared instance of the Positions resource.

data/lib/DhanHQ/models/search_result.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Models
+    # Lightweight result returned by Instrument.search for agent-friendly security resolution.
+    class SearchResult < BaseModel
+      attributes :security_id, :symbol_name, :display_name, :exchange_segment, :instrument,
+                 :instrument_type, :lot_size, :tick_size, :expiry_date, :strike_price,
+                 :option_type, :underlying_symbol, :isin
+    end
+  end
+end

data/lib/DhanHQ/models/trade.rb

@@ -44,6 +44,19 @@ module DhanHQ
                  :create_time, :update_time, :exchange_time, :drv_expiry_date,
                  :drv_option_type, :drv_strike_price
 
+      # Returns a concise prompt-friendly summary of the trade.
+      def to_prompt
+        parts = [
+          "#{transaction_type} #{traded_quantity}x #{trading_symbol || security_id}",
+          "@ ₹#{traded_price}",
+          "on #{exchange_segment}/#{product_type}"
+        ]
+        parts << "order=#{order_id}" if order_id
+        parts << "charges=₹#{total_charges}" if respond_to?(:total_charges) && total_charges
+        parts << "time=#{create_time}" if create_time
+        parts.join(", ")
+      end
+
       class << self
         ##
         # Provides a shared instance of the Trades resource for current day tradebook APIs.

data/lib/DhanHQ/models/twap_order.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "../contracts/twap_order_contract"
+
+module DhanHQ
+  module Models
+    ##
+    # Model for creating and managing TWAP Orders.
+    #
+    # TWAP (Time-Weighted Average Price) orders split a large order into smaller
+    # slices distributed evenly across a defined time window. This minimizes market
+    # impact and achieves execution closer to the period's average price.
+    #
+    # @note **Static IP Whitelisting**: TWAP order creation, modification, and
+    #   cancellation APIs require Static IP whitelisting.
+    #
+    # @example Create a TWAP order
+    #   order = DhanHQ::Models::TwapOrder.create(
+    #     dhan_client_id: "1000000003",
+    #     transaction_type: "SELL",
+    #     exchange_segment: "NSE_EQ",
+    #     product_type: "INTRADAY",
+    #     order_type: "MARKET",
+    #     validity: "DAY",
+    #     security_id: "11536",
+    #     quantity: 500,
+    #     price: 0,                    # MARKET order
+    #     slice_interval: 300,         # 5 minutes
+    #     start_time: "09:30:00",
+    #     end_time: "15:00:00"
+    #   )
+    #   puts "TWAP Order ID: #{order.order_id} - #{order.order_status}"
+    #
+    # @example Modify a TWAP order (extend window)
+    #   order = DhanHQ::Models::TwapOrder.find(order_id)
+    #   order.modify(
+    #     dhan_client_id: "1000000003",
+    #     order_id: order_id,
+    #     end_time: "15:30:00",
+    #     slice_interval: 600
+    #   )
+    #
+    # @example Cancel a TWAP order
+    #   order = DhanHQ::Models::TwapOrder.find(order_id)
+    #   order.cancel
+    #
+    class TwapOrder < BaseModel
+      include Concerns::ApiResponseHandler
+
+      attributes :dhan_client_id, :order_id, :correlation_id, :order_status,
+                 :transaction_type, :exchange_segment, :product_type, :order_type,
+                 :validity, :trading_symbol, :security_id, :quantity,
+                 :remaining_quantity, :price, :trigger_price, :after_market_order,
+                 :slice_interval, :start_time, :end_time, :leg_name,
+                 :create_time, :update_time, :exchange_time, :drv_expiry_date,
+                 :drv_option_type, :drv_strike_price,
+                 :oms_error_code, :oms_error_description, :average_traded_price, :filled_qty
+
+      class << self
+        # @return [DhanHQ::Resources::TwapOrders]
+        def resource
+          @resource ||= DhanHQ::Resources::TwapOrders.new
+        end
+
+        # Retrieves all TWAP orders for the day.
+        #
+        # @return [Array<TwapOrder>]
+        def all
+          response = resource.all
+          return [] unless response.is_a?(Array)
+
+          response.map { |o| new(o, skip_validation: true) }
+        end
+
+        # Retrieves a specific TWAP order by ID.
+        #
+        # @param order_id [String]
+        # @return [TwapOrder, nil]
+        def find(order_id)
+          response = resource.find(order_id)
+          return nil unless response.is_a?(Hash) && response.any?
+
+          new(response, skip_validation: true)
+        end
+
+        # Creates a new TWAP order.
+        #
+        # @param params [Hash{Symbol => String, Integer, Float}]
+        # @return [TwapOrder, nil]
+        def create(params)
+          normalized = snake_case(params)
+          config = DhanHQ.configuration
+          normalized[:dhan_client_id] ||= config.client_id if config&.client_id
+          validate_params!(normalized, DhanHQ::Contracts::TwapOrderCreateContract)
+          formatted = camelize_keys(normalized)
+          response = resource.create(formatted)
+          return nil unless response.is_a?(Hash) && response["orderId"]
+
+          new(order_id: response["orderId"], order_status: response["orderStatus"], skip_validation: true)
+        end
+      end
+
+      # Modifies an existing TWAP order.
+      #
+      # @param new_params [Hash{Symbol => String, Integer, Float}]
+      # @return [TwapOrder, nil]
+      def modify(new_params)
+        raise "Order ID is required to modify a TWAP order" unless order_id
+
+        DhanHQ.logger&.info("[DhanHQ::Models::TwapOrder] Modifying order #{order_id}")
+        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::TwapOrderModifyContract)
+        formatted = camelize_keys(full_params)
+        response = self.class.resource.update(order_id, formatted)
+        success = handle_api_response(response, success_key: "orderId",
+                                                context: "[DhanHQ::Models::TwapOrder] Modification")
+        return self.class.find(order_id) if success
+
+        nil
+      end
+
+      # Cancels the TWAP order.
+      #
+      # @return [Boolean] true when cancelled successfully
+      def cancel
+        raise "Order ID is required to cancel a TWAP order" unless order_id
+
+        response = self.class.resource.cancel(order_id)
+        response.is_a?(Hash) && response["orderStatus"] == DhanHQ::Constants::OrderStatus::CANCELLED
+      end
+    end
+  end
+end

data/lib/DhanHQ/option_analytics/black_scholes.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  # Option analytics calculations for derivatives trading.
+  module OptionAnalytics
+    # Black-Scholes option pricing model for calculating theoretical option prices and Greeks.
+    #
+    # @example Calculate option price
+    #   price = DhanHQ::OptionAnalytics::BlackScholes.price(
+    #     spot: 24000,
+    #     strike: 24200,
+    #     time_to_expiry: 0.038, # ~10 days
+    #     risk_free_rate: 0.065,
+    #     volatility: 0.15,
+    #     option_type: :call
+    #   )
+    #
+    class BlackScholes
+      # Calculate theoretical option price using Black-Scholes model.
+      #
+      # @param spot [Float] Current spot price
+      # @param strike [Float] Strike price
+      # @param time_to_expiry [Float] Time to expiry in years
+      # @param risk_free_rate [Float] Risk-free interest rate (annualized)
+      # @param volatility [Float] Implied volatility (annualized)
+      # @param option_type [Symbol] :call or :put
+      # @return [Float] Theoretical option price
+      def self.price(spot:, strike:, time_to_expiry:, risk_free_rate:, volatility:, option_type:)
+        return 0.0 if time_to_expiry <= 0
+
+        d1 = calculate_d1(spot, strike, time_to_expiry, risk_free_rate, volatility)
+        d2 = calculate_d2(d1, time_to_expiry, volatility)
+
+        if option_type == :call
+          (spot * normal_cdf(d1)) - (strike * Math.exp(-risk_free_rate * time_to_expiry) * normal_cdf(d2))
+        else
+          (strike * Math.exp(-risk_free_rate * time_to_expiry) * normal_cdf(-d2)) - (spot * normal_cdf(-d1))
+        end
+      end
+
+      # Calculate option Greeks (Delta, Gamma, Theta, Vega, Rho).
+      #
+      # @param spot [Float] Current spot price
+      # @param strike [Float] Strike price
+      # @param time_to_expiry [Float] Time to expiry in years
+      # @param risk_free_rate [Float] Risk-free interest rate (annualized)
+      # @param volatility [Float] Implied volatility (annualized)
+      # @param option_type [Symbol] :call or :put
+      # @return [Hash] Hash with :delta, :gamma, :theta, :vega, :rho
+      def self.greeks(spot:, strike:, time_to_expiry:, risk_free_rate:, volatility:, option_type:)
+        return empty_greeks if time_to_expiry <= 0
+
+        d1 = calculate_d1(spot, strike, time_to_expiry, risk_free_rate, volatility)
+        d2 = calculate_d2(d1, time_to_expiry, volatility)
+
+        gamma = normal_pdf(d1) / (spot * volatility * Math.sqrt(time_to_expiry))
+
+        theta = if option_type == :call
+                  calculate_call_theta(spot, strike, time_to_expiry, risk_free_rate, volatility, d1, d2)
+                else
+                  calculate_put_theta(spot, strike, time_to_expiry, risk_free_rate, volatility, d1, d2)
+                end
+
+        vega = spot * normal_pdf(d1) * Math.sqrt(time_to_expiry) / 100
+
+        rho = if option_type == :call
+                calculate_call_rho(spot, strike, time_to_expiry, risk_free_rate, d2)
+              else
+                calculate_put_rho(spot, strike, time_to_expiry, risk_free_rate, d2)
+              end
+
+        {
+          delta: calculate_delta(spot, strike, time_to_expiry, risk_free_rate, volatility, option_type),
+          gamma: gamma,
+          theta: theta / 365.0, # Daily theta
+          vega: vega,
+          rho: rho / 100.0
+        }
+      end
+
+      # Calculate implied volatility using Newton-Raphson method.
+      #
+      # @param market_price [Float] Observed market price of the option
+      # @param spot [Float] Current spot price
+      # @param strike [Float] Strike price
+      # @param time_to_expiry [Float] Time to expiry in years
+      # @param risk_free_rate [Float] Risk-free interest rate (annualized)
+      # @param option_type [Symbol] :call or :put
+      # @param tolerance [Float] Convergence tolerance (default: 0.0001)
+      # @param max_iterations [Integer] Maximum iterations (default: 100)
+      # @return [Float] Implied volatility
+      # rubocop:disable Metrics/ParameterLists
+      def self.implied_volatility(market_price:, spot:, strike:, time_to_expiry:, risk_free_rate:, option_type:,
+                                  tolerance: 0.0001, max_iterations: 100)
+        # rubocop:enable Metrics/ParameterLists
+        return 0.0 if time_to_expiry <= 0 || market_price <= 0
+
+        # Initial guess
+        iv = 0.2
+        max_iterations.times do
+          theoretical_price = price(
+            spot: spot, strike: strike, time_to_expiry: time_to_expiry,
+            risk_free_rate: risk_free_rate, volatility: iv, option_type: option_type
+          )
+
+          diff = theoretical_price - market_price
+          return iv if diff.abs < tolerance
+
+          # Vega for Newton-Raphson
+          vega = spot * normal_pdf(calculate_d1(spot, strike, time_to_expiry, risk_free_rate, iv)) *
+                 Math.sqrt(time_to_expiry)
+
+          return iv if vega < 1e-10
+
+          iv -= diff / vega
+          iv = [iv, 0.001].max # Prevent negative volatility
+        end
+
+        iv
+      end
+
+      class << self
+        private
+
+        def calculate_d1(spot, strike, time_to_expiry, risk_free_rate, volatility)
+          (Math.log(spot / strike) + ((risk_free_rate + ((volatility**2) / 2)) * time_to_expiry)) /
+            (volatility * Math.sqrt(time_to_expiry))
+        end
+
+        def calculate_d2(d1_val, time_to_expiry, volatility)
+          d1_val - (volatility * Math.sqrt(time_to_expiry))
+        end
+
+        def calculate_delta(spot, strike, time_to_expiry, risk_free_rate, volatility, option_type)
+          d1_val = calculate_d1(spot, strike, time_to_expiry, risk_free_rate, volatility)
+
+          if option_type == :call
+            normal_cdf(d1_val)
+          else
+            normal_cdf(d1_val) - 1
+          end
+        end
+
+        def calculate_call_theta(spot, strike, time_to_expiry, risk_free_rate, volatility, d1_val, d2_val)
+          term1 = -(spot * normal_pdf(d1_val) * volatility) / (2 * Math.sqrt(time_to_expiry))
+          term2 = risk_free_rate * strike * Math.exp(-risk_free_rate * time_to_expiry) * normal_cdf(d2_val)
+          term1 - term2
+        end
+
+        def calculate_put_theta(spot, strike, time_to_expiry, risk_free_rate, volatility, d1_val, d2_val)
+          term1 = -(spot * normal_pdf(d1_val) * volatility) / (2 * Math.sqrt(time_to_expiry))
+          term2 = -risk_free_rate * strike * Math.exp(-risk_free_rate * time_to_expiry) * normal_cdf(-d2_val)
+          term1 - term2
+        end
+
+        def calculate_call_rho(_spot, strike, time_to_expiry, risk_free_rate, d2_val)
+          strike * time_to_expiry * Math.exp(-risk_free_rate * time_to_expiry) * normal_cdf(d2_val)
+        end
+
+        def calculate_put_rho(_spot, strike, time_to_expiry, risk_free_rate, d2_val)
+          -strike * time_to_expiry * Math.exp(-risk_free_rate * time_to_expiry) * normal_cdf(-d2_val)
+        end
+
+        def empty_greeks
+          { delta: 0.0, gamma: 0.0, theta: 0.0, vega: 0.0, rho: 0.0 }
+        end
+
+        # rubocop:disable Naming/MethodParameterName
+        # Standard normal cumulative distribution function
+        def normal_cdf(x)
+          0.5 * (1 + erf(x / Math.sqrt(2)))
+        end
+
+        # Standard normal probability density function
+        def normal_pdf(x)
+          Math.exp(-0.5 * (x**2)) / Math.sqrt(2 * Math::PI)
+        end
+
+        # Error function approximation (Abramowitz and Stegun)
+        def erf(x)
+          sign = x.negative? ? -1 : 1
+          x = x.abs
+
+          t = 1.0 / (1.0 + (0.327_591_1 * x))
+          y = 1.0 - (((((((((1.061_40_5429 * t) - 1.453_152_027) * t) + 1.421_413_741) * t) -
+                      0.284_496_736) * t) + 0.254_829_592) * t * Math.exp(-x * x))
+
+          sign * y
+        end
+        # rubocop:enable Naming/MethodParameterName
+      end
+    end
+  end
+end

data/lib/DhanHQ/option_analytics/max_pain.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module OptionAnalytics
+    # Max Pain calculator for option chain analysis.
+    #
+    # Max Pain is the strike price at which the maximum number of options
+    # (both calls and puts) would expire worthless. It is believed that
+    # the underlying asset tends to gravitate towards this price at expiry.
+    #
+    # @example Calculate Max Pain
+    #   option_data = [
+    #     { strike: 24000, call_oi: 1000, put_oi: 500 },
+    #     { strike: 24100, call_oi: 800, put_oi: 700 },
+    #     { strike: 24200, call_oi: 600, put_oi: 900 },
+    #     ...
+    #   ]
+    #   max_pain = DhanHQ::OptionAnalytics::MaxPain.calculate(option_data)
+    #   #=> 24100
+    #
+    class MaxPain
+      # Calculate Max Pain strike price.
+      #
+      # @param option_data [Array<Hash>] Array of option data with :strike, :call_oi, :put_oi
+      # @return [Integer, Float] Strike price with maximum pain
+      def self.calculate(option_data)
+        return nil if option_data.nil? || option_data.empty?
+
+        strikes = option_data.map { |d| d[:strike] || d["strike"] }
+
+        # Calculate total pain for each possible strike
+        pain_values = strikes.map do |strike|
+          total_pain = option_data.sum do |data|
+            s = data[:strike] || data["strike"]
+            call_oi = (data[:call_oi] || data["call_oi"] || 0).to_i
+            put_oi = (data[:put_oi] || data["put_oi"] || 0).to_i
+
+            calculate_pain_at_strike(s, strike, call_oi, put_oi)
+          end
+
+          { strike: strike, pain: total_pain }
+        end
+
+        # Find strike with minimum pain (Max Pain)
+        pain_values.min_by { |v| v[:pain] }[:strike]
+      end
+
+      # Calculate Max Pain with detailed breakdown.
+      #
+      # @param option_data [Array<Hash>] Array of option data with :strike, :call_oi, :put_oi
+      # @return [Hash] Hash with :max_pain_strike, :total_pain, and :pain_distribution
+      def self.detailed(option_data)
+        return nil if option_data.nil? || option_data.empty?
+
+        strikes = option_data.map { |d| d[:strike] || d["strike"] }
+
+        pain_distribution = strikes.map do |strike|
+          total_pain = option_data.sum do |data|
+            s = data[:strike] || data["strike"]
+            call_oi = (data[:call_oi] || data["call_oi"] || 0).to_i
+            put_oi = (data[:put_oi] || data["put_oi"] || 0).to_i
+
+            calculate_pain_at_strike(s, strike, call_oi, put_oi)
+          end
+
+          { strike: strike, pain: total_pain }
+        end
+
+        max_pain_entry = pain_distribution.min_by { |v| v[:pain] }
+
+        {
+          max_pain_strike: max_pain_entry[:strike],
+          total_pain: max_pain_entry[:pain],
+          pain_distribution: pain_distribution
+        }
+      end
+
+      # Calculate Put-Call Ratio from option data.
+      #
+      # @param option_data [Array<Hash>] Array of option data with :call_oi, :put_oi
+      # @return [Float] Put-Call Ratio
+      def self.put_call_ratio(option_data)
+        return 0.0 if option_data.nil? || option_data.empty?
+
+        total_call_oi = option_data.sum { |d| (d[:call_oi] || d["call_oi"] || 0).to_i }
+        total_put_oi = option_data.sum { |d| (d[:put_oi] || d["put_oi"] || 0).to_i }
+
+        return 0.0 if total_call_oi.zero?
+
+        total_put_oi.to_f / total_call_oi
+      end
+
+      class << self
+        private
+
+        # Calculate total pain at a given strike price.
+        # Pain is the loss that option writers would incur if the underlying
+        # expires at that strike.
+        def calculate_pain_at_strike(current_strike, expiry_strike, call_oi, put_oi)
+          # Call writers lose when price goes above strike
+          call_pain = if expiry_strike > current_strike
+                        (expiry_strike - current_strike) * call_oi
+                      else
+                        0
+                      end
+
+          # Put writers lose when price goes below strike
+          put_pain = if expiry_strike < current_strike
+                       (current_strike - expiry_strike) * put_oi
+                     else
+                       0
+                     end
+
+          call_pain + put_pain
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/option_analytics.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "option_analytics/black_scholes"
+require_relative "option_analytics/max_pain"
+
+module DhanHQ
+  # Option analytics calculations for derivatives trading.
+  #
+  # Provides Black-Scholes pricing, Greeks calculation, implied volatility,
+  # and Max Pain analysis for option chain data.
+  #
+  # @example Calculate option price and Greeks
+  #   price = DhanHQ::OptionAnalytics::BlackScholes.price(
+  #     spot: 24000,
+  #     strike: 24200,
+  #     time_to_expiry: 0.038,
+  #     risk_free_rate: 0.065,
+  #     volatility: 0.15,
+  #     option_type: :call
+  #   )
+  #
+  #   greeks = DhanHQ::OptionAnalytics::BlackScholes.greeks(
+  #     spot: 24000,
+  #     strike: 24200,
+  #     time_to_expiry: 0.038,
+  #     risk_free_rate: 0.065,
+  #     volatility: 0.15,
+  #     option_type: :call
+  #   )
+  #
+  # @example Calculate Max Pain
+  #   max_pain = DhanHQ::OptionAnalytics::MaxPain.calculate(option_data)
+  #
+  module OptionAnalytics
+  end
+end

data/lib/DhanHQ/resources/iceberg_orders.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../concerns/order_audit"
+
+module DhanHQ
+  module Resources
+    # Resource client for Iceberg order management.
+    class IcebergOrders < BaseAPI
+      include DhanHQ::Concerns::OrderAudit
+
+      API_TYPE = :order_api
+      HTTP_PATH = "/v2/orders/iceberg"
+
+      # Lists all iceberg orders for the account.
+      #
+      # @return [Array<Hash>]
+      def all
+        get("")
+      end
+
+      # Creates a new iceberg order.
+      #
+      # @param params [Hash]
+      # @return [Hash]
+      def create(params)
+        ensure_live_trading!
+        log_order_context("DHAN_ICEBERG_ORDER_ATTEMPT", params)
+        post("", params: params)
+      end
+
+      # Fetches a specific iceberg order by ID.
+      #
+      # @param order_id [String]
+      # @return [Hash]
+      def find(order_id)
+        get("/#{order_id}")
+      end
+
+      # Updates an existing iceberg order.
+      #
+      # @param order_id [String]
+      # @param params [Hash]
+      # @return [Hash]
+      def update(order_id, params)
+        ensure_live_trading!
+        log_order_context("DHAN_ICEBERG_ORDER_MODIFY_ATTEMPT", params.merge(order_id: order_id))
+        put("/#{order_id}", params: params)
+      end
+
+      # Cancels an iceberg order.
+      #
+      # @param order_id [String]
+      # @return [Hash]
+      def cancel(order_id)
+        ensure_live_trading!
+        log_order_context("DHAN_ICEBERG_ORDER_CANCEL_ATTEMPT", { order_id: order_id })
+        delete("/#{order_id}")
+      end
+    end
+  end
+end