schwab_rb 0.3.12 → 0.4.0

data/lib/schwab_rb/clients/base_client.rb

@@ -49,27 +49,33 @@ module SchwabRb
       @token_manager.token_age
     end
 
-    def get_account(account_hash, fields: nil, return_data_objects: true)
-      # Account balances, positions, and orders for a given account hash.
+    def get_account(account_hash = nil, account_name: nil, fields: nil, return_data_objects: true)
+      # Account balances, positions, and orders for a given account.
       #
+      # @param account_hash [String] The account hash (optional if account_name provided)
+      # @param account_name [String] The account name from account_names.json (takes priority)
       # @param fields [Array] Balances displayed by default, additional fields can be
       # added here by adding values from Account.fields.
       # @param return_data_objects [Boolean] Whether to return data objects or raw JSON
-      refresh_token_if_needed
+      resolved_hash = resolve_account_hash(account_name: account_name, account_hash: account_hash)
 
-      fields = convert_enum_iterable(fields, SchwabRb::Account::Statuses) if fields
+      with_account_hash_retry(resolved_hash) do
+        refresh_token_if_needed
 
-      params = {}
-      params[:fields] = fields.join(",") if fields
+        fields = convert_enum_iterable(fields, SchwabRb::Account::Statuses) if fields
 
-      path = "/trader/v1/accounts/#{account_hash}"
-      response = get(path, params)
+        params = {}
+        params[:fields] = fields.join(",") if fields
 
-      if return_data_objects
-        account_data = JSON.parse(response.body, symbolize_names: true)
-        SchwabRb::DataObjects::Account.build(account_data)
-      else
-        response
+        path = "/trader/v1/accounts/#{resolved_hash}"
+        response = get(path, params)
+
+        if return_data_objects
+          account_data = JSON.parse(response.body, symbolize_names: true)
+          SchwabRb::DataObjects::Account.build(account_data)
+        else
+          response
+        end
       end
     end
 
@@ -109,46 +115,74 @@ module SchwabRb
       path = "/trader/v1/accounts/accountNumbers"
       response = get(path, {})
 
+      account_numbers_data = JSON.parse(response.body, symbolize_names: true)
+
+      begin
+        hash_manager = SchwabRb::AccountHashManager.new
+        hash_manager.update_hashes_from_api_response(account_numbers_data)
+      rescue SchwabRb::AccountHashManager::AccountNamesFileNotFoundError
+        # Silently skip if account names file doesn't exist - not all users will use this feature
+      end
+
       if return_data_objects
-        account_numbers_data = JSON.parse(response.body, symbolize_names: true)
         SchwabRb::DataObjects::AccountNumbers.build(account_numbers_data)
       else
         response
       end
     end
 
-    def get_order(order_id, account_hash, return_data_objects: true)
+    def available_account_names
+      # Returns a list of available account names from account_names.json
+      # Returns empty array if account_names.json doesn't exist
+      #
+      # @return [Array<String>] List of account names
+      hash_manager = SchwabRb::AccountHashManager.new
+      hash_manager.available_account_names
+    end
+
+    def get_order(order_id, account_hash = nil, account_name: nil, return_data_objects: true)
       # Get a specific order for a specific account by its order ID.
       #
       # @param order_id [String] The order ID.
-      # @param account_hash [String] The account hash.
+      # @param account_hash [String] The account hash (optional if account_name provided)
+      # @param account_name [String] The account name from account_names.json (takes priority)
       # @param return_data_objects [Boolean] Whether to return data objects or raw JSON
-      refresh_token_if_needed
+      resolved_hash = resolve_account_hash(account_name: account_name, account_hash: account_hash)
 
-      path = "/trader/v1/accounts/#{account_hash}/orders/#{order_id}"
-      response = get(path, {})
+      with_account_hash_retry(resolved_hash) do
+        refresh_token_if_needed
 
-      if return_data_objects
-        order_data = JSON.parse(response.body, symbolize_names: true)
-        SchwabRb::DataObjects::Order.build(order_data)
-      else
-        response
+        path = "/trader/v1/accounts/#{resolved_hash}/orders/#{order_id}"
+        response = get(path, {})
+
+        if return_data_objects
+          order_data = JSON.parse(response.body, symbolize_names: true)
+          SchwabRb::DataObjects::Order.build(order_data)
+        else
+          response
+        end
       end
     end
 
-    def cancel_order(order_id, account_hash)
+    def cancel_order(order_id, account_hash = nil, account_name: nil)
       # Cancel a specific order for a specific account.
       #
       # @param order_id [String] The order ID.
-      # @param account_hash [String] The account hash.
-      refresh_token_if_needed
+      # @param account_hash [String] The account hash (optional if account_name provided)
+      # @param account_name [String] The account name from account_names.json (takes priority)
+      resolved_hash = resolve_account_hash(account_name: account_name, account_hash: account_hash)
+
+      with_account_hash_retry(resolved_hash) do
+        refresh_token_if_needed
 
-      path = "/trader/v1/accounts/#{account_hash}/orders/#{order_id}"
-      delete(path)
+        path = "/trader/v1/accounts/#{resolved_hash}/orders/#{order_id}"
+        delete(path)
+      end
     end
 
     def get_account_orders(
-      account_hash,
+      account_hash = nil,
+      account_name: nil,
       max_results: nil,
       from_entered_datetime: nil,
       to_entered_datetime: nil,
@@ -157,34 +191,40 @@ module SchwabRb
     )
       # Orders for a specific account. Optionally specify a single status on which to filter.
       #
+      # @param account_hash [String] The account hash (optional if account_name provided)
+      # @param account_name [String] The account name from account_names.json (takes priority)
       # @param max_results [Integer] The maximum number of orders to retrieve.
       # @param from_entered_datetime [DateTime] Start of the query date range (default: 60 days ago).
       # @param to_entered_datetime [DateTime] End of the query date range (default: now).
       # @param status [String] Restrict query to orders with this status.
       # @param return_data_objects [Boolean] Whether to return data objects or raw JSON
-      refresh_token_if_needed
+      resolved_hash = resolve_account_hash(account_name: account_name, account_hash: account_hash)
 
-      from_entered_datetime = DateTime.now.new_offset(0) - 60 if from_entered_datetime.nil?
+      with_account_hash_retry(resolved_hash) do
+        refresh_token_if_needed
 
-      to_entered_datetime = DateTime.now if to_entered_datetime.nil?
+        from_entered_datetime = DateTime.now.new_offset(0) - 60 if from_entered_datetime.nil?
 
-      status = convert_enum(status, SchwabRb::Order::Statuses) if status
+        to_entered_datetime = DateTime.now if to_entered_datetime.nil?
 
-      path = "/trader/v1/accounts/#{account_hash}/orders"
-      params = make_order_query(
-        max_results: max_results,
-        from_entered_datetime: from_entered_datetime,
-        to_entered_datetime: to_entered_datetime,
-        status: status
-      )
+        status = convert_enum(status, SchwabRb::Order::Statuses) if status
 
-      response = get(path, params)
+        path = "/trader/v1/accounts/#{resolved_hash}/orders"
+        params = make_order_query(
+          max_results: max_results,
+          from_entered_datetime: from_entered_datetime,
+          to_entered_datetime: to_entered_datetime,
+          status: status
+        )
 
-      if return_data_objects
-        orders_data = JSON.parse(response.body, symbolize_names: true)
-        orders_data.map { |order_data| SchwabRb::DataObjects::Order.build(order_data) }
-      else
-        response
+        response = get(path, params)
+
+        if return_data_objects
+          orders_data = JSON.parse(response.body, symbolize_names: true)
+          orders_data.map { |order_data| SchwabRb::DataObjects::Order.build(order_data) }
+        else
+          response
+        end
       end
     end
 
@@ -222,53 +262,79 @@ module SchwabRb
       end
     end
 
-    def place_order(account_hash, order_spec)
+    def place_order(order_spec, account_hash = nil, account_name: nil)
       # Place an order for a specific account. If order creation is successful,
       # the response will contain the ID of the generated order.
       #
+      # @param account_hash [String] The account hash (optional if account_name provided)
+      # @param order_spec [Hash, SchwabRb::Orders::Builder] The order specification
+      # @param account_name [String] The account name from account_names.json (takes priority)
+      #
       # Note: Unlike most methods in this library, successful responses typically
       # do not contain JSON data, and attempting to extract it may raise an exception.
-      refresh_token_if_needed
+      resolved_hash = resolve_account_hash(account_name: account_name, account_hash: account_hash)
 
-      order_spec = order_spec.build if order_spec.is_a?(SchwabRb::Orders::Builder)
+      with_account_hash_retry(resolved_hash) do
+        refresh_token_if_needed
 
-      path = "/trader/v1/accounts/#{account_hash}/orders"
-      post(path, order_spec)
+        order_spec = order_spec.build if order_spec.is_a?(SchwabRb::Orders::Builder)
+
+        path = "/trader/v1/accounts/#{resolved_hash}/orders"
+        post(path, order_spec)
+      end
     end
 
-    def replace_order(account_hash, order_id, order_spec)
+    def replace_order(order_id, order_spec, account_hash = nil, account_name: nil)
       # Replace an existing order for an account.
       # The existing order will be replaced by the new order.
       # Once replaced, the old order will be canceled and a new order will be created.
-      refresh_token_if_needed
+      #
+      # @param account_hash [String] The account hash (optional if account_name provided)
+      # @param order_id [String] The order ID to replace
+      # @param order_spec [Hash, SchwabRb::Orders::Builder] The new order specification
+      # @param account_name [String] The account name from account_names.json (takes priority)
+      resolved_hash = resolve_account_hash(account_name: account_name, account_hash: account_hash)
+
+      with_account_hash_retry(resolved_hash) do
+        refresh_token_if_needed
 
-      order_spec = order_spec.build if order_spec.is_a?(SchwabRb::Orders::Builder)
+        order_spec = order_spec.build if order_spec.is_a?(SchwabRb::Orders::Builder)
 
-      path = "/trader/v1/accounts/#{account_hash}/orders/#{order_id}"
-      put(path, order_spec)
+        path = "/trader/v1/accounts/#{resolved_hash}/orders/#{order_id}"
+        put(path, order_spec)
+      end
     end
 
-    def preview_order(account_hash, order_spec, return_data_objects: true)
+    def preview_order(order_spec, account_hash = nil, account_name: nil, return_data_objects: true)
       # Preview an order, i.e., test whether an order would be accepted by the
       # API and see the structure it would result in.
+      #
+      # @param account_hash [String] The account hash (optional if account_name provided)
+      # @param order_spec [Hash, SchwabRb::Orders::Builder] The order specification to preview
+      # @param account_name [String] The account name from account_names.json (takes priority)
       # @param return_data_objects [Boolean] Whether to return data objects or raw JSON
-      refresh_token_if_needed
+      resolved_hash = resolve_account_hash(account_name: account_name, account_hash: account_hash)
 
-      order_spec = order_spec.build if order_spec.is_a?(SchwabRb::Orders::Builder)
+      with_account_hash_retry(resolved_hash) do
+        refresh_token_if_needed
 
-      path = "/trader/v1/accounts/#{account_hash}/previewOrder"
-      response = post(path, order_spec)
+        order_spec = order_spec.build if order_spec.is_a?(SchwabRb::Orders::Builder)
 
-      if return_data_objects
-        preview_data = JSON.parse(response.body, symbolize_names: true)
-        SchwabRb::DataObjects::OrderPreview.build(preview_data)
-      else
-        response
+        path = "/trader/v1/accounts/#{resolved_hash}/previewOrder"
+        response = post(path, order_spec)
+
+        if return_data_objects
+          preview_data = JSON.parse(response.body, symbolize_names: true)
+          SchwabRb::DataObjects::OrderPreview.build(preview_data)
+        else
+          response
+        end
       end
     end
 
     def get_transactions(
-      account_hash,
+      account_hash = nil,
+      account_name: nil,
       start_date: nil,
       end_date: nil,
       transaction_types: nil,
@@ -277,69 +343,78 @@ module SchwabRb
     )
       # Transactions for a specific account.
       #
-      # @param account_hash [String] Account hash corresponding to the account.
+      # @param account_hash [String] The account hash (optional if account_name provided)
+      # @param account_name [String] The account name from account_names.json (takes priority)
       # @param start_date [Date, DateTime] Start date for transactions (default: 60 days ago).
       # @param end_date [Date, DateTime] End date for transactions (default: now).
       # @param transaction_types [Array] List of transaction types to filter by.
       # @param symbol [String] Filter transactions by the specified symbol.
       # @param return_data_objects [Boolean] Whether to return data objects or raw JSON
-      refresh_token_if_needed
-
-      transaction_types = if transaction_types
-                            convert_enum_iterable(transaction_types, SchwabRb::Transaction::Types)
-      else
-        get_valid_enum_values(SchwabRb::Transaction::Types)
-                          end
-
-      start_date = if start_date.nil?
-                     format_date_as_iso("start_date", DateTime.now.new_offset(0) - 60)
-      else
-        format_date_as_iso("start_date", start_date)
+      resolved_hash = resolve_account_hash(account_name: account_name, account_hash: account_hash)
+
+      with_account_hash_retry(resolved_hash) do
+        refresh_token_if_needed
+
+        transaction_types = if transaction_types
+                              convert_enum_iterable(transaction_types, SchwabRb::Transaction::Types)
+        else
+          get_valid_enum_values(SchwabRb::Transaction::Types)
+                            end
+
+        start_date = if start_date.nil?
+                       format_date_as_iso("start_date", DateTime.now.new_offset(0) - 60)
+        else
+          format_date_as_iso("start_date", start_date)
+                     end
+
+        end_date = if end_date.nil?
+                     format_date_as_iso("end_date", DateTime.now.new_offset(0))
+        else
+          format_date_as_iso("end_date", end_date)
                    end
 
-      end_date = if end_date.nil?
-                   format_date_as_iso("end_date", DateTime.now.new_offset(0))
-      else
-        format_date_as_iso("end_date", end_date)
-                 end
-
-      params = {
-        "types" => transaction_types.sort.join(","),
-        "startDate" => start_date,
-        "endDate" => end_date
-      }
-      params["symbol"] = symbol unless symbol.nil?
-
-      path = "/trader/v1/accounts/#{account_hash}/transactions"
-      response = get(path, params)
-
-      if return_data_objects
-        transactions_data = JSON.parse(response.body, symbolize_names: true)
-        transactions_data.map do |transaction_data|
-          SchwabRb::DataObjects::Transaction.build(transaction_data)
+        params = {
+          "types" => transaction_types.sort.join(","),
+          "startDate" => start_date,
+          "endDate" => end_date
+        }
+        params["symbol"] = symbol unless symbol.nil?
+
+        path = "/trader/v1/accounts/#{resolved_hash}/transactions"
+        response = get(path, params)
+
+        if return_data_objects
+          transactions_data = JSON.parse(response.body, symbolize_names: true)
+          transactions_data.map do |transaction_data|
+            SchwabRb::DataObjects::Transaction.build(transaction_data)
+          end
+        else
+          response
         end
-      else
-        response
       end
     end
 
-    def get_transaction(account_hash, activity_id, return_data_objects: true)
+    def get_transaction(activity_id, account_hash = nil, account_name: nil, return_data_objects: true)
       # Transaction for a specific account.
       #
-      # @param account_hash [String] Account hash corresponding to the account whose
-      #                              transactions should be returned.
-      # @param activity_id [String] ID of the order for which to return data.
+      # @param account_hash [String] The account hash (optional if account_name provided)
+      # @param activity_id [String] ID of the transaction to retrieve
+      # @param account_name [String] The account name from account_names.json (takes priority)
       # @param return_data_objects [Boolean] Whether to return data objects or raw JSON
-      refresh_token_if_needed
+      resolved_hash = resolve_account_hash(account_name: account_name, account_hash: account_hash)
 
-      path = "/trader/v1/accounts/#{account_hash}/transactions/#{activity_id}"
-      response = get(path, {})
+      with_account_hash_retry(resolved_hash) do
+        refresh_token_if_needed
 
-      if return_data_objects
-        transaction_data = JSON.parse(response.body, symbolize_names: true)
-        SchwabRb::DataObjects::Transaction.build(transaction_data)
-      else
-        response
+        path = "/trader/v1/accounts/#{resolved_hash}/transactions/#{activity_id}"
+        response = get(path, {})
+
+        if return_data_objects
+          transaction_data = JSON.parse(response.body, symbolize_names: true)
+          SchwabRb::DataObjects::Transaction.build(transaction_data)
+        else
+          response
+        end
       end
     end
 
@@ -855,6 +930,47 @@ module SchwabRb
 
     private
 
+    # Resolves account identifier to actual account hash
+    # Accepts either account name (looked up in account_hashes.json) or direct hash
+    # Priority: account_name > account_hash
+    def resolve_account_hash(account_name: nil, account_hash: nil)
+      # If account_name is provided, look it up
+      if account_name
+        hash_manager = SchwabRb::AccountHashManager.new
+        resolved_hash = hash_manager.get_hash_by_name(account_name)
+
+        unless resolved_hash
+          raise ArgumentError,
+                "Account name '#{account_name}' not found in account hashes. " \
+                "Make sure get_account_numbers has been called to populate hashes."
+        end
+
+        return resolved_hash
+      end
+
+      # Fall back to account_hash if provided
+      if account_hash
+        return account_hash
+      end
+
+      # Neither was provided
+      raise ArgumentError, "Either account_name or account_hash must be provided"
+    end
+
+    # Wraps API calls that use account_hash with retry logic for stale hashes
+    def with_account_hash_retry(account_hash)
+      yield
+    rescue StandardError => e
+      # Try refreshing account hashes and retry once
+      begin
+        get_account_numbers
+        yield
+      rescue StandardError => retry_error
+        # If it fails again, raise the retry error
+        raise retry_error
+      end
+    end
+
     def make_order_query(
       max_results: nil,
       from_entered_datetime: nil,

data/lib/schwab_rb/configuration.rb

@@ -2,13 +2,19 @@
 
 module SchwabRb
   class Configuration
-    attr_accessor :logger, :log_file, :log_level, :silence_output
+    attr_accessor :logger, :log_file, :log_level, :silence_output,
+                  :schwab_home, :account_hashes_path, :account_names_path
 
     def initialize
       @logger = nil
       @log_file = ENV.fetch("SCHWAB_LOGFILE", nil)
       @log_level = ENV.fetch("SCHWAB_LOG_LEVEL", "WARN").upcase
       @silence_output = ENV.fetch("SCHWAB_SILENCE_OUTPUT", "false").downcase == "true"
+
+      default_home = File.expand_path("~/.schwab_rb")
+      @schwab_home = ENV.fetch("SCHWAB_HOME", default_home)
+      @account_hashes_path = ENV.fetch("SCHWAB_ACCOUNT_HASHES_PATH", File.join(@schwab_home, "account_hashes.json"))
+      @account_names_path = ENV.fetch("SCHWAB_ACCOUNT_NAMES_PATH", File.join(@schwab_home, "account_names.json"))
     end
 
     def has_external_logger?

data/lib/schwab_rb/orders/iron_condor_order.rb

@@ -1,33 +1,35 @@
 # frozen_string_literal: true
 
-require 'schwab_rb'
+require "schwab_rb"
 
 module SchwabRb
   module Orders
     class IronCondorOrder
       class << self
         def build(
-          account_number:,
           put_short_symbol:,
           put_long_symbol:,
           call_short_symbol:,
           call_long_symbol:,
           price:,
+          stop_price: nil,
+          order_type: nil,
+          duration: SchwabRb::Orders::Duration::DAY,
           credit_debit: :credit,
           order_instruction: :open,
           quantity: 1
         )
           schwab_order_builder.new.tap do |builder|
-            builder.set_account_number(account_number)
-            builder.set_order_strategy_type('SINGLE')
+            builder.set_order_strategy_type(SchwabRb::Order::OrderStrategyTypes::SINGLE)
             builder.set_session(SchwabRb::Orders::Session::NORMAL)
-            builder.set_duration(SchwabRb::Orders::Duration::DAY)
-            builder.set_order_type(order_type(credit_debit))
+            builder.set_duration(duration)
+            builder.set_order_type(order_type || determine_order_type(credit_debit))
             builder.set_complex_order_strategy_type(SchwabRb::Order::ComplexOrderStrategyTypes::IRON_CONDOR)
             builder.set_quantity(quantity)
             builder.set_price(price)
+            builder.set_stop_price(stop_price) if stop_price && order_type == SchwabRb::Order::Types::STOP_LIMIT
 
-            instructions = leg_instructions_for_position(order_instruction, credit_debit)
+            instructions = leg_instructions_for_position(order_instruction)
 
             builder.add_option_leg(
               instructions[:put_short],
@@ -52,7 +54,7 @@ module SchwabRb
           end
         end
 
-        def order_type(credit_debit)
+        def determine_order_type(credit_debit)
           if credit_debit == :credit
             SchwabRb::Order::Types::NET_CREDIT
           else
@@ -60,37 +62,23 @@ module SchwabRb
           end
         end
 
-        def leg_instructions_for_position(order_instruction, credit_debit)
-          if order_instruction == :open && credit_debit == :credit
+        def leg_instructions_for_position(order_instruction)
+          if order_instruction == :open
             {
               put_short: SchwabRb::Orders::OptionInstructions::SELL_TO_OPEN,
               put_long: SchwabRb::Orders::OptionInstructions::BUY_TO_OPEN,
               call_short: SchwabRb::Orders::OptionInstructions::SELL_TO_OPEN,
               call_long: SchwabRb::Orders::OptionInstructions::BUY_TO_OPEN
             }
-          elsif order_instruction == :open && credit_debit == :debit
-            {
-              put_short: SchwabRb::Orders::OptionInstructions::BUY_TO_OPEN,
-              put_long: SchwabRb::Orders::OptionInstructions::SELL_TO_OPEN,
-              call_short: SchwabRb::Orders::OptionInstructions::BUY_TO_OPEN,
-              call_long: SchwabRb::Orders::OptionInstructions::SELL_TO_OPEN
-            }
-          elsif order_instruction == :close && credit_debit == :credit
+          elsif order_instruction == :close
             {
               put_short: SchwabRb::Orders::OptionInstructions::BUY_TO_CLOSE,
               put_long: SchwabRb::Orders::OptionInstructions::SELL_TO_CLOSE,
               call_short: SchwabRb::Orders::OptionInstructions::BUY_TO_CLOSE,
               call_long: SchwabRb::Orders::OptionInstructions::SELL_TO_CLOSE
             }
-          elsif order_instruction == :close && credit_debit == :debit
-            {
-              put_short: SchwabRb::Orders::OptionInstructions::SELL_TO_CLOSE,
-              put_long: SchwabRb::Orders::OptionInstructions::BUY_TO_CLOSE,
-              call_short: SchwabRb::Orders::OptionInstructions::SELL_TO_CLOSE,
-              call_long: SchwabRb::Orders::OptionInstructions::BUY_TO_CLOSE
-            }
           else
-            raise "Unsupported order instruction: #{order_instruction} with credit/debit: #{credit_debit}"
+            raise "Unsupported order instruction: #{order_instruction}"
           end
         end
 

data/lib/schwab_rb/orders/oco_order.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'order_factory'
+
+module SchwabRb
+  module Orders
+    class OcoOrder
+      class << self
+        # Build an OCO (One Cancels Another) order with 2 or more child orders
+        #
+        # @param child_order_specs [Array<Hash>] Array of order specifications for child orders.
+        #   Each spec should include all parameters needed for OrderFactory.build
+        # @return [SchwabRb::Orders::Builder] A builder configured with OCO order structure
+        #
+        # @example Simple OCO with two equity orders
+        #   OcoOrder.build(
+        #     child_order_specs: [
+        #       {
+        #         strategy_type: 'single',
+        #         symbol: 'XYZ   240315C00500000',
+        #         price: 45.97,
+        #         account_number: '12345',
+        #         order_instruction: :close,
+        #         credit_debit: :credit,
+        #         quantity: 2
+        #       },
+        #       {
+        #         strategy_type: 'single',
+        #         symbol: 'XYZ   240315C00500000',
+        #         price: 37.00,
+        #         stop_price: 37.03,
+        #         account_number: '12345',
+        #         order_instruction: :close,
+        #         credit_debit: :credit,
+        #         quantity: 2
+        #       }
+        #     ]
+        #   )
+        def build(child_order_specs:)
+          raise ArgumentError, "OCO orders require at least 2 child orders" if child_order_specs.length < 2
+
+          builder = schwab_order_builder.new
+          builder.set_order_strategy_type(SchwabRb::Order::OrderStrategyTypes::OCO)
+
+          # Build each child order using OrderFactory
+          child_order_specs.each do |child_spec|
+            child_order = build_child_order(child_spec)
+            builder.add_child_order_strategy(child_order)
+          end
+
+          builder
+        end
+
+        private
+
+        def build_child_order(child_spec)
+          # Use OrderFactory to recursively build child orders
+          # This allows OCO orders to contain any type of order (single, vertical, iron condor, etc.)
+
+          OrderFactory.build(**child_spec)
+        end
+
+        def schwab_order_builder
+          SchwabRb::Orders::Builder
+        end
+      end
+    end
+  end
+end