my-ib-api 0.0.1

data/lib/ib/messages/incoming/order_status.rb

@@ -0,0 +1,81 @@
+module IB
+  module Messages
+    module Incoming
+
+      # :status - String: Displays the order status. Possible values include:
+      # - PendingSubmit - indicates that you have transmitted the order, but
+      #   have not yet received confirmation that it has been accepted by the
+      #   order destination. NOTE: This order status is NOT sent back by TWS
+      #   and should be explicitly set by YOU when an order is submitted.
+      # - PendingCancel - indicates that you have sent a request to cancel
+      #   the order but have not yet received cancel confirmation from the
+      #   order destination. At this point, your order cancel is not confirmed.
+      #   You may still receive an execution while your cancellation request
+      #   is pending. NOTE: This order status is not sent back by TWS and
+      #   should be explicitly set by YOU when an order is canceled.
+      # - PreSubmitted - indicates that a simulated order type has been
+      #   accepted by the IB system and that this order has yet to be elected.
+      #   The order is held in the IB system until the election criteria are
+      #   met. At that time the order is transmitted to the order destination
+      #   as specified.
+      # - Submitted - indicates that your order has been accepted at the order
+      #   destination and is working.
+      # - Cancelled - indicates that the balance of your order has been
+      #   confirmed canceled by the IB system. This could occur unexpectedly
+      #   when IB or the destination has rejected your order.
+      # - ApiCancelled - canceled via API
+      # - Filled - indicates that the order has been completely filled.
+      # - Inactive - indicates that the order has been accepted by the system
+      #   (simulated orders) or an exchange (native orders) but that currently
+      #   the order is inactive due to system, exchange or other issues.
+      # :why_held - This property contains the comma-separated list of reasons for
+      #      order to be held. For example, when TWS is trying to locate shares for
+      #      a short sell, the value used to indicate this is 'locate'.
+      OrderStatus = def_message [3, 6],
+                                [:order_state, :local_id, :int],
+                                [:order_state, :status, :string],
+                                [:order_state, :filled, :int],
+                                [:order_state, :remaining, :int],
+                                [:order_state, :average_fill_price, :decimal],
+                                [:order_state, :perm_id, :int],
+                                [:order_state, :parent_id, :int],
+                                [:order_state, :last_fill_price, :decimal],
+                                [:order_state, :client_id, :int],
+                                [:order_state, :why_held, :string]
+      class OrderStatus
+
+        def order_state
+          @order_state ||= IB::OrderState.new @data[:order_state]
+        end
+
+        # Accessors to make OpenOrder and OrderStatus messages API-compatible
+        def client_id
+          order_state.client_id
+        end
+
+        def parent_id
+          order_state.parent_id
+        end
+
+        def perm_id
+          order_state.perm_id
+        end
+
+        def local_id
+          order_state.local_id
+        end
+
+        alias order_id local_id
+
+        def status
+          order_state.status
+        end
+
+        def to_human
+          "<OrderStatus: #{order_state}>"
+        end
+
+      end # class OrderStatus
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming/portfolio_value.rb

@@ -0,0 +1,39 @@
+module IB
+  module Messages
+    module Incoming
+
+      PortfolioValue = def_message [7, 7],
+                                   [:contract, :con_id, :int],
+                                   [:contract, :symbol, :string],
+                                   [:contract, :sec_type, :string],
+                                   [:contract, :expiry, :string],
+                                   [:contract, :strike, :decimal],
+                                   [:contract, :right, :string],
+                                   [:contract, :multiplier, :string],
+                                   [:contract, :primary_exchange, :string],
+                                   [:contract, :currency, :string],
+                                   [:contract, :local_symbol, :string],
+                                   [:position, :int],
+                                   [:market_price, :decimal],
+                                   [:market_value, :decimal],
+                                   [:average_cost, :decimal],
+                                   [:unrealized_pnl, :decimal_max], # May be nil!
+                                   [:realized_pnl, :decimal_max], #   May be nil!
+                                   [:account_name, :string]
+      class PortfolioValue
+
+        def contract
+          @contract = IB::Contract.build @data[:contract]
+        end
+
+        def to_human
+          "<PortfolioValue: #{contract.to_human} (#{position}): Market #{market_price}" +
+              " price #{market_value} value; PnL: #{unrealized_pnl} unrealized," +
+              " #{realized_pnl} realized; account #{account_name}>"
+        end
+      end # PortfolioValue
+
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming/real_time_bar.rb

@@ -0,0 +1,32 @@
+module IB
+  module Messages
+    module Incoming
+
+      # RealTimeBar contains following @data:
+      #    :request_id - The ID of the *request* to which this is responding
+      #    :time - The date-time stamp of the start of the bar. The format is offset in
+      #            seconds from the beginning of 1970, same format as the UNIX epoch time
+      #    :bar - received RT Bar
+      RealTimeBar = def_message [50, 3],
+                                [:request_id, :int],
+                                [:bar, :time, :int],
+                                [:bar, :open, :decimal],
+                                [:bar, :high, :decimal],
+                                [:bar, :low, :decimal],
+                                [:bar, :close, :decimal],
+                                [:bar, :volume, :int],
+                                [:bar, :wap, :decimal],
+                                [:bar, :trades, :int]
+      class RealTimeBar
+        def bar
+          @bar = IB::Bar.new @data[:bar]
+        end
+
+        def to_human
+          "<RealTimeBar: #{request_id} #{bar}>"
+        end
+      end # RealTimeBar
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming/scanner_data.rb

@@ -0,0 +1,53 @@
+module IB
+  module Messages
+    module Incoming
+
+      # This method receives the requested market scanner data results.
+      # ScannerData contains following @data:
+      # :request_id - The ID of the request to which this row is responding
+      # :count - Number of data points returned (size of :results).
+      # :results - an Array of Hashes, each hash contains a set of
+      #            data about one scanned Contract:
+      #            :contract - a full description of the contract (details).
+      #            :distance - Varies based on query.
+      #            :benchmark - Varies based on query.
+      #            :projection - Varies based on query.
+      #            :legs - Describes combo legs when scan is returning EFP.
+      ScannerData = def_message [20, 3],
+                                [:request_id, :int], # request id
+                                [:count, :int]
+      class ScannerData
+        attr_accessor :results
+
+        def load
+          super
+
+          @results = Array.new(@data[:count]) do |_|
+            {:rank => socket.read_int,
+             :contract =>
+                 Contract.build(
+                     :con_id => socket.read_int,
+                     :symbol => socket.read_string,
+                     :sec_type => socket.read_string,
+                     :expiry => socket.read_string,
+                     :strike => socket.read_decimal,
+                     :right => socket.read_string,
+                     :exchange => socket.read_string,
+                     :currency => socket.read_string,
+                     :local_symbol => socket.read_string,
+                     :contract_detail =>
+                         IB::ContractDetail.new(
+                             :market_name => socket.read_string,
+                             :trading_class => socket.read_string)),
+             :distance => socket.read_string,
+             :benchmark => socket.read_string,
+             :projection => socket.read_string,
+             :legs => socket.read_string,
+            }
+          end
+        end
+      end # ScannerData
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming/ticks.rb

@@ -0,0 +1,131 @@
+# All message classes related to ticks located here
+module IB
+  module Messages
+    module Incoming
+
+      class AbstractTick < AbstractMessage
+        # Returns Symbol with a meaningful name for received tick type
+        def type
+          TICK_TYPES[@data[:tick_type]]
+        end
+
+        def to_human
+          "<#{self.message_type} #{type}:" +
+              @data.map do |key, value|
+                " #{key} #{value}" unless [:version, :ticker_id, :tick_type].include?(key)
+              end.compact.join(',') + " >"
+        end
+      end
+
+      # The IB code seems to dispatch up to two wrapped objects for this message, a tickPrice
+      # and sometimes a tickSize, which seems to be identical to the TICK_SIZE object.
+      #
+      # Important note from
+      # http://chuckcaplan.com/twsapi/index.php/void%20tickPrice%28%29 :
+      #
+      # "The low you get is NOT the low for the day as you'd expect it
+      # to be. It appears IB calculates the low based on all
+      # transactions after 4pm the previous day. The most inaccurate
+      # results occur when the stock moves up in the 4-6pm aftermarket
+      # on the previous day and then gaps open upward in the
+      # morning. The low you receive from TWS can be easily be several
+      # points different from the actual 9:30am-4pm low for the day in
+      # cases like this. If you require a correct traded low for the
+      # day, you can't get it from the TWS API. One possible source to
+      # help build the right data would be to compare against what Yahoo
+      # lists on finance.yahoo.com/q?s=ticker under the "Day's Range"
+      # statistics (be careful here, because Yahoo will use anti-Denial
+      # of Service techniques to hang your connection if you try to
+      # request too many bytes in a short period of time from them). For
+      # most purposes, a good enough approach would start by replacing
+      # the TWS low for the day with Yahoo's day low when you first
+      # start watching a stock ticker; let's call this time T. Then,
+      # update your internal low if the bid or ask tick you receive is
+      # lower than that for the remainder of the day. You should check
+      # against Yahoo again at time T+20min to handle the occasional
+      # case where the stock set a new low for the day in between
+      # T-20min (the real time your original quote was from, taking into
+      # account the delay) and time T. After that you should have a
+      # correct enough low for the rest of the day as long as you keep
+      # updating based on the bid/ask. It could still get slightly off
+      # in a case where a short transaction setting a new low appears in
+      # between ticks of data that TWS sends you.  The high is probably
+      # distorted in the same way the low is, which would throw your
+      # results off if the stock traded after-hours and gapped down. It
+      # should be corrected in a similar way as described above if this
+      # is important to you."
+      #
+      # IB then emits at most 2 events on eWrapper:
+      #          tickPrice( tickerId, tickType, price, canAutoExecute)
+      #          tickSize( tickerId, sizeTickType, size)
+      TickPrice = def_message [1, 6], AbstractTick,
+                              [:ticker_id, :int],
+                              [:tick_type, :int],
+                              [:price, :decimal],
+                              [:size, :int],
+                              [:can_auto_execute, :int]
+
+      TickSize = def_message [2, 6], AbstractTick,
+                             [:ticker_id, :int],
+                             [:tick_type, :int],
+                             [:size, :int]
+
+      TickGeneric = def_message [45, 6], AbstractTick,
+                                [:ticker_id, :int],
+                                [:tick_type, :int],
+                                [:value, :decimal]
+
+      TickString = def_message [46, 6], AbstractTick,
+                               [:ticker_id, :int],
+                               [:tick_type, :int],
+                               [:value, :string]
+
+      TickEFP = def_message [47, 6], AbstractTick,
+                            [:ticker_id, :int],
+                            [:tick_type, :int],
+                            [:basis_points, :decimal],
+                            [:formatted_basis_points, :string],
+                            [:implied_futures_price, :decimal],
+                            [:hold_days, :int],
+                            [:dividend_impact, :decimal],
+                            [:dividends_to_expiry, :decimal]
+
+      # This message is received when the market in an option or its underlier moves.
+      # TWS option model volatilities, prices, and deltas, along with the present
+      # value of dividends expected on that options underlier are received.
+      # TickOption message contains following @data:
+      #    :ticker_id - Id that was specified previously in the call to reqMktData()
+      #    :tick_type - Specifies the type of option computation (see TICK_TYPES).
+      #    :implied_volatility - The implied volatility calculated by the TWS option
+      #                          modeler, using the specified :tick_type value.
+      #    :delta - The option delta value.
+      #    :option_price - The option price.
+      #    :pv_dividend - The present value of dividends expected on the options underlier
+      #    :gamma - The option gamma value.
+      #    :vega - The option vega value.
+      #    :theta - The option theta value.
+      #    :under_price - The price of the underlying.
+      TickOptionComputation = TickOption =
+          def_message([21, 6], AbstractTick,
+                      [:ticker_id, :int],
+                      [:tick_type, :int],
+                      #                       What is the "not yet computed" indicator:
+                      [:implied_volatility, :decimal_limit_1], # -1 and below
+                      [:delta, :decimal_limit_2], #              -2 and below
+                      [:option_price, :decimal_limit_1], #       -1   -"-
+                      [:pv_dividend, :decimal_limit_1], #        -1   -"-
+                      [:gamma, :decimal_limit_2], #              -2   -"-
+                      [:vega, :decimal_limit_2], #               -2   -"-
+                      [:theta, :decimal_limit_2], #              -2   -"-
+                      [:under_price, :decimal_limit_1]) do
+
+            "<TickOption #{type} for #{:ticker_id}: underlying @ #{under_price}, "+
+                "option @ #{option_price}, IV #{implied_volatility}%, delta #{delta}, " +
+                "gamma #{gamma}, vega #{vega}, theta #{theta}, pv_dividend #{pv_dividend}>"
+          end
+
+      TickSnapshotEnd = def_message 57, [:ticker_id, :int]
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/outgoing.rb

@@ -0,0 +1,331 @@
+require 'ib/messages/outgoing/abstract_message'
+
+# TODO: Don't instantiate messages, use their classes as just namespace for .encode/decode
+
+module IB
+  module Messages
+
+    # Outgoing IB messages (sent to TWS/Gateway)
+    module Outgoing
+      extend Messages # def_message macros
+
+      ### Defining (short) Outgoing Message classes for IB:
+
+      ## Empty messages (no data)
+
+      # Request the open orders that were placed from THIS client. Each open order
+      # will be fed back through the OpenOrder and OrderStatus messages ONCE.
+      # NB: Client with a client_id of 0 will also receive the TWS-owned open orders.
+      # These orders will be associated with the client and a new orderId will be
+      # generated. This association will persist over multiple API and TWS sessions.
+      RequestOpenOrders = def_message 5
+
+      # Request the open orders placed from all clients and also from TWS. Each open
+      # order will be fed back through the OpenOrder and OrderStatus messages ONCE.
+      # Note this does not re-bind those Orders to requesting Client!
+      # Use RequestAutoOpenOrders to request such re-binding.
+      RequestAllOpenOrders = def_message 16
+
+      # Request that newly created TWS orders be implicitly associated with this client.
+      # When a new TWS order is created, the order will be associated with this client
+      # and automatically fed back through the OpenOrder and OrderStatus messages.
+      # It is a 'continuous' request such that it gets turned 'on' when called with a
+      # TRUE auto_bind parameter. When it's called with FALSE auto_bind, new TWS orders
+      # will not bind to this client going forward. Note that TWS orders can only be
+      # bound to clients with a client_id of 0. TODO: how to properly test this?
+      # data = { :auto_bind => boolean }
+      RequestAutoOpenOrders = def_message 15, :auto_bind
+
+      # Requests an XML document that describes the valid parameters that a scanner
+      # subscription can have (for outgoing RequestScannerSubscription message).
+      RequestScannerParameters = def_message 24
+
+      CancelNewsBulletins = def_message 13
+      RequestManagedAccounts = def_message 17
+      RequestCurrentTime = def_message 49
+      RequestGlobalCancel = def_message 58
+
+      ## Data format is: @data = { :id => ticker_id}
+      CancelMarketData = def_message 2
+      CancelMarketDepth = def_message 11
+      CancelScannerSubscription = def_message 23
+      CancelHistoricalData = def_message 25
+      CancelRealTimeBars = def_message 51
+
+      ## Data format is: @data = { :id => request_id }
+      CancelFundamentalData = def_message 53
+      CancelCalculateImpliedVolatility = CancelImpliedVolatility = def_message(56)
+      CancelCalculateOptionPrice = CancelOptionPrice = def_message(57)
+
+      ## Data format is: @data ={ :id => local_id of order to cancel }
+      CancelOrder = def_message 4
+
+      # Request the next valid ID that can be used when placing an order. Responds with
+      # NextValidId message, and the id returned is that next valid Id for orders.
+      # That ID will reflect any autobinding that has occurred (which generates new
+      # IDs and increments the next valid ID therein).
+      # @data = { :number of ids requested => int } NB: :number option is ignored by TWS!
+      RequestIds = def_message 8, [:number, 1]
+      # data = { :all_messages => boolean }
+      RequestNewsBulletins = def_message 12, :all_messages
+      # data = { :log_level => int }
+      SetServerLoglevel = def_message 14, :log_level
+      # data = { :fa_data_type => int }
+      RequestFA = def_message 18, :fa_data_type
+      # data = { :fa_data_type => int, :xml => String }
+      ReplaceFA = def_message 19, :fa_data_type, :xml
+      # data = { :market_data_type => int }
+
+      # @data = { :subscribe => boolean,
+      #           :account_code => Advisor accounts only. Empty ('') for a standard account. }
+      RequestAccountUpdates = RequestAccountData = def_message([6, 2],
+                                                               [:subscribe, true],
+                                                               :account_code)
+
+      # data => { :id => request_id (int), :contract => Contract }
+      #
+      # Special case for options: "wildcards" in the Contract fields retrieve Option chains
+      #   strike = 0 means all strikes
+      #   right = "" meanns both call and put
+      #   expiry = "" means all expiries
+      #   expiry = "2013" means all expiries in 2013
+      #   expiry = "201311" means all expiries in Nov 2013
+      # You'll get several ContractData (10) messages back if there is more than one match.
+      # When all the matches are delivered you'll get ContractDataEnd (52) message.
+      RequestContractDetails = RequestContractData =
+          def_message([9, 6],
+                      [:contract, :serialize_short, [:con_id, :include_expired, :sec_id]])
+
+      # data = { :id => ticker_id (int), :contract => Contract, :num_rows => int }
+      RequestMarketDepth = def_message([10, 3],
+                                       [:contract, :serialize_short, []],
+                                       :num_rows)
+
+      # When this message is sent, TWS responds with ExecutionData messages, each
+      # containing the execution report that meets the specified criteria.
+      # @data={:id =>         int: :request_id,
+      #        :client_id => int: Filter the results based on the clientId.
+      #        :acct_code => Filter the results based on based on account code.
+      #                      Note: this is only relevant for Financial Advisor accts.
+      #        :sec_type =>  Filter the results based on the order security type.
+      #        :time =>      Filter the results based on execution reports received
+      #                      after the specified time - format "yyyymmdd-hh:mm:ss"
+      #        :symbol   =>  Filter the results based on the order symbol.
+      #        :exchange =>  Filter the results based on the order exchange
+      #        :side =>  Filter the results based on the order action: BUY/SELL/SSHORT
+      RequestExecutions = def_message([7, 3],
+                                      :client_id,
+                                      :acct_code,
+                                      :time, # Format "yyyymmdd-hh:mm:ss"
+                                      :symbol,
+                                      :sec_type,
+                                      :exchange,
+                                      :side)
+
+      # data = { :id => ticker_id (int),
+      #          :contract => IB::Contract,
+      #          :exercise_action => int, 1 = exercise, 2 = lapse
+      #          :exercise_quantity => int, The number of contracts to be exercised
+      #          :account => string,
+      #          :override => int: Specifies whether your setting will override the
+      #                       system's natural action. For example, if your action
+      #                       is "exercise" and the option is not in-the-money, by
+      #                       natural action the option would not exercise. If you
+      #                       have override set to "yes" the natural action would be
+      #                       overridden and the out-of-the money option would be
+      #                       exercised. Values are:
+      #                              - 0 = do not override
+      #                              - 1 = override
+      ExerciseOptions = def_message(21,
+                                    [:contract, :serialize_short],
+                                    :exercise_action,
+                                    :exercise_quantity,
+                                    :account,
+                                    :override)
+
+      # @data={:id => int: ticker_id - Must be a unique value. When the market data
+      #                                returns, it will be identified by this tag,
+      #      :contract => IB::Contract, requested contract.
+      #      :tick_list => String: comma delimited list of requested tick groups:
+      #        Group ID - Description - Requested Tick Types
+      #        100 - Option Volume (currently for stocks) - 29, 30
+      #        101 - Option Open Interest (currently for stocks) - 27, 28
+      #        104 - Historical Volatility (currently for stocks) - 23
+      #        106 - Option Implied Volatility (currently for stocks) - 24
+      #        162 - Index Future Premium - 31
+      #        165 - Miscellaneous Stats - 15, 16, 17, 18, 19, 20, 21
+      #        221 - Mark Price (used in TWS P&L computations) - 37
+      #        225 - Auction values (volume, price and imbalance) - 34, 35, 36
+      #        233 - RTVolume - 48
+      #        236 - Shortable - 46
+      #        256 - Inventory - ?
+      #        258 - Fundamental Ratios - 47
+      #        411 - Realtime Historical Volatility - 58
+      #      :snapshot => bool: Check to return a single snapshot of market data and
+      #                   have the market data subscription canceled. Do not enter any
+      #                   :tick_list values if you use snapshot. }
+      RequestMarketData =
+          def_message([1, 9],
+                      [:contract, :serialize_long, [:con_id]],
+                      [:contract, :serialize_legs, []],
+                      [:contract, :serialize_under_comp, []],
+                      [:tick_list, lambda do |tick_list|
+                        tick_list.is_a?(Array) ? tick_list.join(',') : (tick_list || '')
+                      end, []],
+                      [:snapshot, false])
+
+      # The API can receive frozen market data from Trader Workstation. Frozen market
+      # data is the last data recorded in our system. During normal trading hours,
+      # the API receives real-time market data. If you use this function, you are
+      # telling TWS to automatically switch to frozen market data AFTER the close.
+      # Then, before the opening of the next trading day, market data will automatically
+      # switch back to real-time market data.
+      # :market_data_type = 1 for real-time streaming, 2 for frozen market data
+      RequestMarketDataType =
+          def_message 59, [:market_data_type,
+                           lambda { |type| MARKET_DATA_TYPES.invert[type] || type }, []]
+
+      # Send this message to receive Reuters global fundamental data. There must be
+      # a subscription to Reuters Fundamental set up in Account Management before
+      # you can receive this data.
+      # data = { :id => int: :request_id,
+      #          :contract => Contract,
+      #          :report_type => String: one of the following:
+      #                   'estimates' - Estimates
+      #                   'finstat'   - Financial statements
+      #                    'snapshot' - Summary   }
+      RequestFundamentalData =
+          def_message(52,
+                      [:contract, :serialize, [:primary_exchange]],
+                      :report_type)
+
+      # data = { :request_id => int, :contract => Contract,
+      #          :option_price => double, :under_price => double }
+      RequestCalculateImpliedVolatility = CalculateImpliedVolatility =
+          RequestImpliedVolatility =
+              def_message(54,
+                          [:contract, :serialize_long, [:con_id]],
+                          :option_price,
+                          :under_price)
+
+      # data = { :request_id => int, :contract => Contract,
+      #          :volatility => double, :under_price => double }
+      RequestCalculateOptionPrice = CalculateOptionPrice = RequestOptionPrice =
+          def_message(55,
+                      [:contract, :serialize_long, [:con_id]],
+                      :volatility,
+                      :under_price)
+
+      # Start receiving market scanner results through the ScannerData messages.
+      # @data = { :id => ticker_id (int),
+      #  :number_of_rows => int: number of rows of data to return for a query.
+      #  :instrument => The instrument type for the scan. Values include
+      #                                'STK', - US stocks
+      #                                'STOCK.HK' - Asian stocks
+      #                                'STOCK.EU' - European stocks
+      #  :location_code => Legal Values include:
+      #                           - STK.US - US stocks
+      #                           - STK.US.MAJOR - US stocks (without pink sheet)
+      #                           - STK.US.MINOR - US stocks (only pink sheet)
+      #                           - STK.HK.SEHK - Hong Kong stocks
+      #                           - STK.HK.ASX - Australian Stocks
+      #                           - STK.EU - European stocks
+      #  :scan_code => The type of the scan, such as HIGH_OPT_VOLUME_PUT_CALL_RATIO.
+      #  :above_price => double: Only contracts with a price above this value.
+      #  :below_price => double: Only contracts with a price below this value.
+      #  :above_volume => int: Only contracts with a volume above this value.
+      #  :market_cap_above => double: Only contracts with a market cap above this
+      #  :market_cap_below => double: Only contracts with a market cap below this value.
+      #  :moody_rating_above => Only contracts with a Moody rating above this value.
+      #  :moody_rating_below => Only contracts with a Moody rating below this value.
+      #  :sp_rating_above => Only contracts with an S&P rating above this value.
+      #  :sp_rating_below => Only contracts with an S&P rating below this value.
+      #  :maturity_date_above => Only contracts with a maturity date later than this
+      #  :maturity_date_below => Only contracts with a maturity date earlier than this
+      #  :coupon_rate_above => double: Only contracts with a coupon rate above this
+      #  :coupon_rate_below => double: Only contracts with a coupon rate below this
+      #  :exclude_convertible => Exclude convertible bonds.
+      #  :scanner_setting_pairs => Used with the scan_code to help further narrow your query.
+      #                            Scanner Setting Pairs are delimited by slashes, making
+      #                            this parameter open ended. Example is "Annual,true" -
+      #                            when used with 'Top Option Implied Vol % Gainers' scan
+      #                            would return annualized volatilities.
+      #  :average_option_volume_above =>  int: Only contracts with average volume above this
+      #  :stock_type_filter => Valid values are:
+      #                          'ALL' (excludes nothing)
+      #                          'STOCK' (excludes ETFs)
+      #                          'ETF' (includes ETFs) }
+      # ------------
+      # To learn all valid parameter values that a scanner subscription can have,
+      # first subscribe to ScannerParameters and send RequestScannerParameters message.
+      # Available scanner parameters values will be listed in received XML document.
+      RequestScannerSubscription =
+          def_message([22, 3],
+                      [:number_of_rows, -1], # was: EOL,
+                      :instrument,
+                      :location_code,
+                      :scan_code,
+                      :above_price,
+                      :below_price,
+                      :above_volume,
+                      :market_cap_above,
+                      :market_cap_below,
+                      :moody_rating_above,
+                      :moody_rating_below,
+                      :sp_rating_above,
+                      :sp_rating_below,
+                      :maturity_date_above,
+                      :maturity_date_below,
+                      :coupon_rate_above,
+                      :coupon_rate_below,
+                      :exclude_convertible,
+                      :average_option_volume_above, # ?
+                      :scanner_setting_pairs,
+                      :stock_type_filter)
+
+      require 'ib/messages/outgoing/place_order'
+      require 'ib/messages/outgoing/bar_requests'
+
+    end # module Outgoing
+  end # module Messages
+end # module IB
+
+__END__
+
+    // outgoing msg id's
+    private static final int REQ_MKT_DATA = 1;
+    private static final int CANCEL_MKT_DATA = 2;
+    private static final int PLACE_ORDER = 3;
+    private static final int CANCEL_ORDER = 4;
+    private static final int REQ_OPEN_ORDERS = 5;
+    private static final int REQ_ACCOUNT_DATA = 6;
+    private static final int REQ_EXECUTIONS = 7;
+    private static final int REQ_IDS = 8;
+    private static final int REQ_CONTRACT_DATA = 9;
+    private static final int REQ_MKT_DEPTH = 10;
+    private static final int CANCEL_MKT_DEPTH = 11;
+    private static final int REQ_NEWS_BULLETINS = 12;
+    private static final int CANCEL_NEWS_BULLETINS = 13;
+    private static final int SET_SERVER_LOGLEVEL = 14;
+    private static final int REQ_AUTO_OPEN_ORDERS = 15;
+    private static final int REQ_ALL_OPEN_ORDERS = 16;
+    private static final int REQ_MANAGED_ACCTS = 17;
+    private static final int REQ_FA = 18;
+    private static final int REPLACE_FA = 19;
+    private static final int REQ_HISTORICAL_DATA = 20;
+    private static final int EXERCISE_OPTIONS = 21;
+    private static final int REQ_SCANNER_SUBSCRIPTION = 22;
+    private static final int CANCEL_SCANNER_SUBSCRIPTION = 23;
+    private static final int REQ_SCANNER_PARAMETERS = 24;
+    private static final int CANCEL_HISTORICAL_DATA = 25;
+    private static final int REQ_CURRENT_TIME = 49;
+    private static final int REQ_REAL_TIME_BARS = 50;
+    private static final int CANCEL_REAL_TIME_BARS = 51;
+    private static final int REQ_FUNDAMENTAL_DATA = 52;
+    private static final int CANCEL_FUNDAMENTAL_DATA = 53;
+    private static final int REQ_CALC_IMPLIED_VOLAT = 54;
+    private static final int REQ_CALC_OPTION_PRICE = 55;
+    private static final int CANCEL_CALC_IMPLIED_VOLAT = 56;
+    private static final int CANCEL_CALC_OPTION_PRICE = 57;
+    private static final int REQ_GLOBAL_CANCEL = 58;
+     private static final int REQ_MARKET_DATA_TYPE = 59;