my-ib-api 0.0.1

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

@@ -0,0 +1,34 @@
+module IB
+  module Messages
+    module Incoming
+
+      # Called Error in Java code, but in fact this type of messages also
+      # deliver system alerts and additional (non-error) info from TWS.
+      ErrorMessage = Error = Alert = def_message([4, 2],
+                                                 [:error_id, :int],
+                                                 [:code, :int],
+                                                 [:message, :string])
+      class Alert
+        # Is it an Error message?
+        def error?
+          code < 1000
+        end
+
+        # Is it a System message?
+        def system?
+          code > 1000 && code < 2000
+        end
+
+        # Is it a Warning message?
+        def warning?
+          code > 2000
+        end
+
+        def to_human
+          "TWS #{ error? ? 'Error' : system? ? 'System' : 'Warning'} #{code}: #{message}"
+        end
+      end # class Alert
+
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,102 @@
+module IB
+  module Messages
+    module Incoming
+      module ContractAccessors
+
+      end
+
+      ContractDetails = ContractData =
+        def_message([10, [6, 8]],
+                    [:request_id, :int], # request id
+                    [:contract, :symbol, :string],
+                    [:contract, :sec_type, :string],
+                    [:contract, :expiry, :string],
+                    [:contract, :strike, :decimal],
+                    [:contract, :right, :string],
+                    [:contract, :exchange, :string],
+                    [:contract, :currency, :string],
+                    [:contract, :local_symbol, :string],
+
+                    [:contract_detail, :market_name, :string], # extended
+                    [:contract_detail, :trading_class, :string],
+                    [:contract, :con_id, :int],
+                    [:contract_detail, :min_tick, :decimal],
+                    [:contract, :multiplier, :string],
+                    [:contract_detail, :order_types, :string],
+                    [:contract_detail, :valid_exchanges, :string],
+                    [:contract_detail, :price_magnifier, :int],
+                    [:contract_detail, :under_con_id, :int],
+                    [:contract_detail, :long_name, :string],
+                    [:contract, :primary_exchange, :string],
+                    [:contract_detail, :contract_month, :string],
+                    [:contract_detail, :industry, :string],
+                    [:contract_detail, :category, :string],
+                    [:contract_detail, :subcategory, :string],
+                    [:contract_detail, :time_zone, :string],
+                    [:contract_detail, :trading_hours, :string],
+                    [:contract_detail, :liquid_hours, :string],
+                    [:contract_detail, :ev_rule, :decimal],
+                    [:contract_detail, :ev_multipler, :string],
+                    [:sec_id_list_count, :int])
+
+
+      class ContractData
+
+        def contract
+          @contract = IB::Contract.build @data[:contract].
+            merge(:contract_detail => contract_detail)
+        end
+
+        def contract_detail
+          @contract_detail = IB::ContractDetail.new @data[:contract_detail]
+        end
+
+        alias contract_details contract_detail
+
+        def load
+          super
+
+          @data[:contract_detail][:sec_id_list] ||= HashWithIndifferentAccess.new
+          @data[:sec_id_list_count].times do
+            @data[:contract_detail][:sec_id_list][socket.read_string] = socket.read_string
+          end
+        end
+
+      end # ContractData
+
+      BondContractData =
+        def_message [18, [4, 6]], ContractData,
+        [:request_id, :int],
+        [:contract, :symbol, :string],
+        [:contract, :sec_type, :string],
+        [:contract_detail, :cusip, :string],
+        [:contract_detail, :coupon, :decimal],
+        [:contract_detail, :maturity, :string],
+        [:contract_detail, :issue_date, :string],
+        [:contract_detail, :ratings, :string],
+        [:contract_detail, :bond_type, :string],
+        [:contract_detail, :coupon_type, :string],
+        [:contract_detail, :convertible, :boolean],
+        [:contract_detail, :callable, :boolean],
+        [:contract_detail, :puttable, :boolean],
+        [:contract_detail, :desc_append, :string],
+        [:contract, :exchange, :string],
+        [:contract, :currency, :string],
+        [:contract_detail, :market_name, :string], # extended
+        [:contract_detail, :trading_class, :string],
+        [:contract, :con_id, :int],
+        [:contract_detail, :min_tick, :decimal],
+        [:contract_detail, :order_types, :string],
+        [:contract_detail, :valid_exchanges, :string],
+        [:contract_detail, :valid_next_option_date, :string],
+        [:contract_detail, :valid_next_option_type, :string],
+        [:contract_detail, :valid_next_option_partial, :string],
+        [:contract_detail, :notes, :string],
+        [:contract_detail, :long_name, :string],
+        [:contract_detail, :ev_rule, :decimal],
+        [:contract_detail, :ev_multipler, :string],
+        [:sec_id_list_count, :int]
+
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,23 @@
+module IB
+  module Messages
+    module Incoming
+
+      # The server sends this message upon accepting a Delta-Neutral DN RFQ
+      # - see API Reference p. 26
+      DeltaNeutralValidation = def_message 56,
+                                           [:request_id, :int],
+                                           [:underlying, :con_id, :int],
+                                           [:underlying, :delta, :decimal],
+                                           [:underlying, :price, :decimal]
+      class DeltaNeutralValidation
+        def underlying
+          @underlying = IB::Underlying.new @data[:underlying]
+        end
+
+        alias under_comp underlying
+
+      end # DeltaNeutralValidation
+
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,54 @@
+module IB
+  module Messages
+    module Incoming
+
+      ExecutionData =
+          def_message [11, [8, 9]],
+                      # The reqID that was specified previously in the call to reqExecution()
+                      [:request_id, :int],
+                      [:execution, :local_id, :int],
+                      [:contract, :con_id, :int],
+                      [:contract, :symbol, :string],
+                      [:contract, :sec_type, :string],
+                      [:contract, :expiry, :string],
+                      [:contract, :strike, :decimal],
+                      [:contract, :right, :string],
+                      [:contract, :multiplier, :string],
+                      [:contract, :exchange, :string],
+                      [:contract, :currency, :string],
+                      [:contract, :local_symbol, :string],
+
+                      [:execution, :exec_id, :string], # Weird format
+                      [:execution, :time, :string],
+                      [:execution, :account_name, :string],
+                      [:execution, :exchange, :string],
+                      [:execution, :side, :string],
+                      [:execution, :quantity, :int],
+                      [:execution, :price, :decimal],
+                      [:execution, :perm_id, :int],
+                      [:execution, :client_id, :int],
+                      [:execution, :liquidation, :int],
+                      [:execution, :cumulative_quantity, :int],
+                      [:execution, :average_price, :decimal],
+                      [:execution, :order_ref, :string],
+                      [:execution, :ev_rule, :string],
+                      [:execution, :ev_multiplier, :decimal]
+
+      class ExecutionData
+
+        def contract
+          @contract = IB::Contract.build @data[:contract]
+        end
+
+        def execution
+          @execution = IB::Execution.new @data[:execution]
+        end
+
+        def to_human
+          "<ExecutionData #{request_id}: #{contract.to_human}, #{execution}>"
+        end
+
+      end # ExecutionData
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,55 @@
+module IB
+  module Messages
+    module Incoming
+
+      # HistoricalData contains following @data:
+      # General:
+      #    :request_id - The ID of the request to which this is responding
+      #    :count - Number of Historical data points returned (size of :results).
+      #    :results - an Array of Historical Data Bars
+      #    :start_date - beginning of returned Historical data period
+      #    :end_date   - end of returned Historical data period
+      # Each returned Bar in @data[:results] Array contains this data:
+      #    :date - The date-time stamp of the start of the bar. The format is
+      #       determined by the RequestHistoricalData formatDate parameter.
+      #    :open -  The bar opening price.
+      #    :high -  The high price during the time covered by the bar.
+      #    :low -   The low price during the time covered by the bar.
+      #    :close - The bar closing price.
+      #    :volume - The volume during the time covered by the bar.
+      #    :trades - When TRADES historical data is returned, represents number of trades
+      #             that occurred during the time period the bar covers
+      #    :wap - The weighted average price during the time covered by the bar.
+      #    :has_gaps - Whether or not there are gaps in the data.
+
+      HistoricalData = def_message [17, 3],
+                                   [:request_id, :int],
+                                   [:start_date, :string],
+                                   [:end_date, :string],
+                                   [:count, :int]
+      class HistoricalData
+        attr_accessor :results
+
+        def load
+          super
+
+          @results = Array.new(@data[:count]) do |_|
+            IB::Bar.new :time => socket.read_string,
+                        :open => socket.read_decimal,
+                        :high => socket.read_decimal,
+                        :low => socket.read_decimal,
+                        :close => socket.read_decimal,
+                        :volume => socket.read_int,
+                        :wap => socket.read_decimal,
+                        :has_gaps => socket.read_string,
+                        :trades => socket.read_int
+          end
+        end
+
+        def to_human
+          "<HistoricalData: #{request_id}, #{count} items, #{start_date} to #{end_date}>"
+        end
+      end # HistoricalData
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,44 @@
+module IB
+  module Messages
+    module Incoming
+
+      MarketDepth =
+          def_message 12, [:request_id, :int],
+                      [:position, :int], # The row Id of this market depth entry.
+                      [:operation, :int], # How it should be applied to the market depth:
+                      #   0 = insert this new order into the row identified by :position
+                      #   1 = update the existing order in the row identified by :position
+                      #   2 = delete the existing order at the row identified by :position
+                      [:side, :int], # side of the book: 0 = ask, 1 = bid
+                      [:price, :decimal],
+                      [:size, :int]
+
+      class MarketDepth
+        def side
+          @data[:side] == 0 ? :ask : :bid
+        end
+
+        def operation
+          @data[:operation] == 0 ? :insert : @data[:operation] == 1 ? :update : :delete
+        end
+
+        def to_human
+          "<#{self.message_type}: #{operation} #{side} @ "+
+              "#{position} = #{price} x #{size}>"
+        end
+      end
+
+      MarketDepthL2 =
+          def_message 13, MarketDepth, # Fields descriptions - see above
+                      [:request_id, :int],
+                      [:position, :int],
+                      [:market_maker, :string], # The exchange hosting this order.
+                      [:operation, :int],
+                      [:side, :int],
+                      [:price, :decimal],
+                      [:size, :int]
+
+
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,18 @@
+module IB
+  module Messages
+    module Incoming
+
+      # This message is always sent by TWS automatically at connect.
+      # The IB::Connection class subscribes to it automatically and stores
+      # the order id in its @next_local_id attribute.
+      NextValidID = NextValidId = def_message(9, [:local_id, :int])
+
+      class NextValidId
+
+        # Legacy accessor
+        alias order_id local_id
+
+      end # class NextValidId
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,232 @@
+module IB
+  module Messages
+    module Incoming
+
+      # OpenOrder is the longest message with complex processing logics
+      OpenOrder =
+          def_message [5, 30],
+                      [:order, :local_id, :int],
+
+                      [:contract, :con_id, :int],
+                      [:contract, :symbol, :string],
+                      [:contract, :sec_type, :string],
+                      [:contract, :expiry, :string],
+                      [:contract, :strike, :decimal],
+                      [:contract, :right, :string],
+                      [:contract, :exchange, :string],
+                      [:contract, :currency, :string],
+                      [:contract, :local_symbol, :string],
+
+                      [:order, :action, :string],
+                      [:order, :total_quantity, :int],
+                      [:order, :order_type, :string],
+                      [:order, :limit_price, :decimal_max],
+                      [:order, :aux_price, :decimal_max],
+                      [:order, :tif, :string],
+                      [:order, :oca_group, :string],
+                      [:order, :account, :string],
+                      [:order, :open_close, :string],
+                      [:order, :origin, :int],
+                      [:order, :order_ref, :string],
+                      [:order, :client_id, :int],
+                      [:order, :perm_id, :int],
+                      [:order, :outside_rth, :boolean], # (@socket.read_int == 1)
+                      [:order, :hidden, :boolean], # (@socket.read_int == 1)
+                      [:order, :discretionary_amount, :decimal],
+                      [:order, :good_after_time, :string],
+                      [:shares_allocation, :string], # deprecated! field
+
+                      [:order, :fa_group, :string],
+                      [:order, :fa_method, :string],
+                      [:order, :fa_percentage, :string],
+                      [:order, :fa_profile, :string],
+                      [:order, :good_till_date, :string],
+                      [:order, :rule_80a, :string],
+                      [:order, :percent_offset, :decimal_max],
+                      [:order, :settling_firm, :string],
+                      [:order, :short_sale_slot, :int],
+                      [:order, :designated_location, :string],
+                      [:order, :exempt_code, :int], # skipped in ver 51?
+                      [:order, :auction_strategy, :int],
+                      [:order, :starting_price, :decimal_max],
+                      [:order, :stock_ref_price, :decimal_max],
+                      [:order, :delta, :decimal_max],
+                      [:order, :stock_range_lower, :decimal_max],
+                      [:order, :stock_range_upper, :decimal_max],
+                      [:order, :display_size, :int],
+                      #@order.rth_only = @socket.read_boolean
+                      [:order, :block_order, :boolean],
+                      [:order, :sweep_to_fill, :boolean],
+                      [:order, :all_or_none, :boolean],
+                      [:order, :min_quantity, :int_max],
+                      [:order, :oca_type, :int],
+                      [:order, :etrade_only, :boolean],
+                      [:order, :firm_quote_only, :boolean],
+                      [:order, :nbbo_price_cap, :decimal_max],
+                      [:order, :parent_id, :int],
+                      [:order, :trigger_method, :int],
+                      [:order, :volatility, :decimal_max],
+                      [:order, :volatility_type, :int],
+                      [:order, :delta_neutral_order_type, :string],
+                      [:order, :delta_neutral_aux_price, :decimal_max]
+
+      class OpenOrder
+
+        # Accessors to make OpenOrder API-compatible with OrderStatus message
+
+        def client_id
+          order.client_id
+        end
+
+        def parent_id
+          order.parent_id
+        end
+
+        def perm_id
+          order.perm_id
+        end
+
+         def local_id
+          order.local_id
+        end
+
+        alias order_id local_id
+
+        def status
+          order.status
+        end
+
+        # Object accessors
+
+        def order
+          @order ||= IB::Order.new @data[:order].merge(:order_state => order_state)
+        end
+
+        def order_state
+          @order_state ||= IB::OrderState.new(
+              @data[:order_state].merge(
+                  :local_id => @data[:order][:local_id],
+                  :perm_id => @data[:order][:perm_id],
+                  :parent_id => @data[:order][:parent_id],
+                  :client_id => @data[:order][:client_id]))
+        end
+
+        def contract
+          @contract ||= IB::Contract.build(
+              @data[:contract].merge(:underlying => underlying)
+          )
+        end
+
+        def underlying
+          @underlying = @data[:underlying_present] ? IB::Underlying.new(@data[:underlying]) : nil
+        end
+
+        alias under_comp underlying
+
+        def load
+          super
+
+          load_map [proc { | | filled?(@data[:order][:delta_neutral_order_type]) },
+                      # As of client v.52, we may receive delta... params in openOrder
+                     [:order, :delta_neutral_con_id, :int],
+                     [:order, :delta_neutral_settling_firm, :string],
+                     [:order, :delta_neutral_clearing_account, :string],
+                     [:order, :delta_neutral_clearing_intent, :string]],
+
+                   [:order, :continuous_update, :int],
+                   [:order, :reference_price_type, :int],
+                   [:order, :trail_stop_price, :decimal_max],
+                   [:order, :trailing_percent, :decimal_max],
+                   [:order, :basis_points, :decimal_max],
+                   [:order, :basis_points_type, :int_max],
+                   [:contract, :legs_description, :string],
+
+                   # As of client v.55, we receive in OpenOrder for Combos:
+                   #    Contract.orderComboLegs Array
+                   #    Order.leg_prices Array
+                   [:contract, :legs, :array, proc do |_|
+                     IB::ComboLeg.new :con_id => socket.read_int,
+                                      :ratio => socket.read_int,
+                                      :action => socket.read_string,
+                                      :exchange => socket.read_string,
+                                      :open_close => socket.read_int,
+                                      :short_sale_slot => socket.read_int,
+                                      :designated_location => socket.read_string,
+                                      :exempt_code => socket.read_int
+                   end],
+                   [:order, :leg_prices, :array, proc { |_| socket.read_decimal_max }],
+                   [:smart_combo_routing_params, :hash],
+
+                   [:order, :scale_init_level_size, :int_max],
+                   [:order, :scale_subs_level_size, :int_max],
+
+                   [:order, :scale_price_increment, :decimal_max],
+                   [proc { | | filled?(@data[:order][:scale_price_increment]) },
+                     # As of client v.54, we may receive scale order fields
+                     [:order, :scale_price_adjust_value, :decimal_max],
+                     [:order, :scale_price_adjust_interval, :int_max],
+                     [:order, :scale_profit_offset, :decimal_max],
+                     [:order, :scale_auto_reset, :boolean],
+                     [:order, :scale_init_position, :int_max],
+                     [:order, :scale_init_fill_qty, :decimal_max],
+                     [:order, :scale_random_percent, :boolean]
+                   ],
+
+                   [:order, :hedge_type, :string],
+                   [proc { | | filled?(@data[:order][:hedge_type]) },
+                     # As of client v.49/50, we can receive hedgeType, hedgeParam
+                     [:order, :hedge_param, :string]
+                   ],
+
+                   [:order, :opt_out_smart_routing, :boolean],
+                   [:order, :clearing_account, :string],
+                   [:order, :clearing_intent, :string],
+                   [:order, :not_held, :boolean],
+
+                   [:underlying_present, :boolean],
+                   [proc { | | filled?(@data[:underlying_present]) },
+                    [:underlying, :con_id, :int],
+                    [:underlying, :delta, :decimal],
+                    [:underlying, :price, :decimal]
+                   ],
+
+                   # TODO: Test Order with algo_params, scale and legs!
+                   [:order, :algo_strategy, :string],
+                   [proc { | | filled?(@data[:order][:algo_strategy]) },
+                    [:order, :algo_params, :hash]
+                   ],
+
+                   [:order, :what_if, :boolean],
+
+                   [:order_state, :status, :string],
+                   # IB uses weird String with Java Double.MAX_VALUE to indicate no value here
+                   [:order_state, :init_margin, :decimal_max], # :string],
+                   [:order_state, :maint_margin, :decimal_max], # :string],
+                   [:order_state, :equity_with_loan, :decimal_max], # :string],
+                   [:order_state, :commission, :decimal_max], # May be nil!
+                   [:order_state, :min_commission, :decimal_max], # May be nil!
+                   [:order_state, :max_commission, :decimal_max], # May be nil!
+                   [:order_state, :commission_currency, :string],
+                   [:order_state, :warning_text, :string]
+        end
+
+        # Check if given value was set by TWS to something vaguely "positive"
+        def filled? value
+          case value
+            when String
+              !value.empty?
+            when Float, Integer
+              value > 0
+            else
+              !!value # to_bool
+          end
+        end
+
+        def to_human
+          "<OpenOrder: #{contract.to_human} #{order.to_human}>"
+        end
+
+      end # class OpenOrder
+    end # module Incoming
+  end # module Messages
+end # module IB