ib-api 10.33.1

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

@@ -0,0 +1,290 @@
+module IB
+  module Messages
+    module Incoming
+      using IB::Support
+      # OpenOrder is the longest message with complex processing logics
+      OpenOrder =
+          def_message [5, 0],   # updated to v. 34 according to python (decoder.py processOpenOrder)
+                      [ :order, :local_id,             :int],
+
+                      [ :contract,                     :contract], # read standard-contract
+                      # [ con_id, symbol,. sec_type, expiry, strike, right, multiplier,
+                      # exchange, currency, local_symbol, trading_class ]
+
+                      [ :order, :action,               :string ],
+                      [ :order, :total_quantity,       :decimal ],
+                      [ :order, :order_type,           :string ],
+                      [ :order, :limit_price,          :decimal ],
+                      [ :order, :aux_price,            :decimal ],
+                      [ :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 ],
+                      [ :order, :hidden,               :boolean ],
+                      [ :order, :discretionary_amount, :decimal ],
+                      [ :order, :good_after_time,      :string ],
+                      [ :shares_allocation,            :string ],    # skip_share_allocation
+
+                      [ :order, :fa_group,             :string ],               # fa_params
+                      [ :order, :fa_method,            :string ],               # fa_params
+                      [ :order, :fa_percentage,        :string ],               # fa_params
+                      [ :order, :fa_profile,           :string ],               # fa_params
+
+                      [ :order, :model_code,           :string ],
+                      [ :order, :good_till_date,       :string ],
+                      [ :order, :rule_80a,             :string ],
+                      [ :order, :percent_offset,       :decimal ],
+                      [ :order, :settling_firm,        :string ],
+                      [ :order, :short_sale_slot,      :int ],        # short_sale_parameter
+                      [ :order, :designated_location,  :string ],     # short_sale_parameter
+                      [ :order, :exempt_code,          :int ],        # short_sale_parameter
+                      [ :order, :auction_strategy,     :int ],        # auction_strategy
+                      [ :order, :starting_price,       :decimal ],    # auction_strategy
+                      [ :order, :stock_ref_price,      :decimal ],    # auction_strategy
+                      [ :order, :delta,                :decimal ],    # auction_strategy
+                      [ :order, :stock_range_lower,    :decimal ],    # auction_strategy
+                      [ :order, :stock_range_upper,    :decimal ],    # auction_strategy
+                      [ :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 ],
+                      [ :order, :oca_type,             :int ],
+                      [ :order, :etrade_only,          :boolean ],    # skip etrade only
+                      [ :order, :firm_quote_only,      :boolean ],    # skip firm quote only
+                      [ :order, :nbbo_price_cap,       :string ],     # skip nbbo_price_cap
+                      [ :order, :parent_id,            :int ],
+                      [ :order, :trigger_method,       :int ],
+                      [ :order, :volatility,           :decimal ],   # vol_order_params
+                      [ :order, :volatility_type,      :int ],       # vol_order_params
+                      [ :order, :delta_neutral_order_type,:string ], # vol_order_params
+                      [ :order, :delta_neutral_aux_price, :decimal ] # vol_order_params
+
+      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
+
+        def conditions
+          order.conditions
+        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 { | | (@data[ :order][:delta_neutral_order_type] != 'None') },
+          load_map [ proc { | | filled?(@data[ :order][:delta_neutral_order_type ] ) }, # todo Testcase!
+                      # 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, :delta_neutral_open_close, :string ],
+                     [ :order, :delta_neutral_short_sale, :bool ],
+                     [ :order, :delta_neutral_short_sale_slot, :int ],
+                     [ :order, :delta_neutral_designated_location, :string ] ],  # end proc
+             [ :order, :continuous_update, :int ],
+             [ :order, :reference_price_type, :int ],                       ### end VolOrderParams (Python)
+             [ :order, :trail_stop_price, :decimal ],   # not trail-orders. see below
+             [ :order, :trailing_percent, :decimal ],
+             [ :order, :basis_points, :decimal ],
+             [ :order, :basis_points_type, :int ],
+
+             [ :contract, :legs_description, :string ],
+
+             # As of client v.55, we receive in OpenOrder for Combos:
+             #    Contract.orderComboLegs Array
+             #    Order.leg_prices Array
+             [ :contract, :combo_legs, :array, proc do |_|
+               IB::ComboLeg.new :con_id => @buffer.read_int,
+                                 :ratio => @buffer.read_int,
+                                :action => @buffer.read_string,
+                              :exchange => @buffer.read_string,
+                            :open_close => @buffer.read_int,
+                       :short_sale_slot => @buffer.read_int,
+                   :designated_location => @buffer.read_string,
+                           :exempt_code => @buffer.read_int
+             end ],
+             [ :order, :leg_prices, :array, proc { |_| buffer.read_decimal } ],   #  needs testing
+             [ :order, :combo_params, :hash ],
+ #, proc do |_|
+#         { tag: buffer.read_string, value: buffer.read_string }  # needs testing
+#  end],
+
+             [ :order, :scale_init_level_size, :int ],
+             [ :order, :scale_subs_level_size, :int ],
+
+             [ :order, :scale_price_increment, :decimal ],
+             [ proc { | | filled?( @data[ :order ][ :scale_price_increment ] ) }, # true or false
+               [ :order, :scale_price_adjust_value,    :decimal ],                # if true
+               [ :order, :scale_price_adjust_interval, :int ] ,
+               [ :order, :scale_profit_offset,         :decimal ],
+               [ :order, :scale_auto_reset,            :boolean ],
+               [ :order, :scale_init_position,         :int ],
+               [ :order, :scale_init_fill_qty,         :decimal ],
+               [ :order, :scale_random_percent,        :boolean ] ], # end of scale price increment
+
+             [ :order, :hedge_type, :string ],                                     # can be nil
+             [ proc { | | filled?(@data[ :order ][ :hedge_type ] ) },              # true or false
+               [ :order, :hedge_param, :string ] ],                                # if true
+
+             [ :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 ] ) },                 # true or false
+              [ :underlying, :con_id, :int ],
+              [ :underlying, :delta, :decimal ],
+              [ :underlying, :price, :decimal ] ],                     # end of underlying present?
+
+             # TODO: Test Order with algo_params, scale and legs!
+             [ :order, :algo_strategy, :string],
+             [ proc { | | filled?(@data[ :order ][ :algo_strategy ] ) },            # true of false
+              [ :order, :algo_params, :hash ] ],                                    # of true
+
+             [ :order, :solicided, :boolean ],
+
+## whatif   serverVersion >= MIN_SERVER_VER_WHAT_IF_EXT_FIELDS
+             [ :order, :what_if,                         :boolean ],
+             [ :order_state, :status,                     :string ],
+             [ :order_state, :init_margin_before,        :decimal ], #  nil unless what_if is true
+             [ :order_state, :maint_margin_before,       :decimal ], #  nil unless what_if is true
+             [ :order_state, :equity_with_loan_before,   :decimal ], #  nil unless what_if is true
+             [ :order_state, :init_margin_change,        :decimal ], #  nil unless what_if is true
+             [ :order_state, :maint_margin_change,       :decimal ], #  nil unless what_if is true
+             [ :order_state, :equity_with_loan_change,   :decimal ], #  nil unless what_if is true
+             [ :order_state, :init_margin_after,         :decimal ], #  nil unless what_if is true
+             [ :order_state, :maint_margin_after,        :decimal ], #  nil unless what_if is true
+             [ :order_state, :equity_with_loan_after,    :decimal ], #  nil unless what_if is true
+             [ :order_state, :commission,                :decimal ], #  nil unless what_if is true
+             [ :order_state, :min_commission,            :decimal ], #  nil unless what_if is true
+             [ :order_state, :max_commission,            :decimal ], #  nil unless what_if is true
+             [ :order_state, :commission_currency,        :string ],  #  nil unless what_if is true
+             [ :order_state, :warning_text,               :string ],  #  nil unless what_if is true
+
+
+             [ :order, :random_size, :boolean ],
+             [ :order, :random_price, :boolean ],
+
+             ## todo: ordertype = PEG BENCH  --  -> test!
+             [ proc { @data[ :order ][ :order_type ] == 'PEG BENCH' },               # true of false
+               [ :order, :reference_contract_id,            :int ],
+               [ :order, :is_pegged_change_amount_decrease, :bool ],
+               [ :order, :pegged_change_amount,             :decimal ],
+               [ :order, :reference_change_amount,          :decimal ],
+               [ :order, :reference_exchange_id, :string ] ],    #  end special parameters PEG BENCH
+
+             [ :order , :conditions, :array, proc {  IB::OrderCondition.make_from( @buffer ) } ],
+             [ proc { !@data[ :order ][ :conditions ].blank?  },                     # true or false
+               [ :order, :conditions_ignore_rth, :bool ],
+               [ :order, :conditions_cancel_order,:bool ] ],
+             #AdjustedOrderParams
+             [ :order, :adjusted_order_type,        :string ],
+             [ :order, :trigger_price,              :decimal ],
+             [ :order, :trail_stop_price,           :decimal ],     #  Traillimit orders
+             [ :order, :limit_price_offset,         :decimal ],
+             [ :order, :adjusted_stop_price,        :decimal ],
+             [ :order, :adjusted_stop_limit_price,  :decimal ],
+             [ :order, :adjusted_trailing_amount,   :decimal ],
+             [ :order, :adjustable_trailing_unit,   :int ],
+             # SoftDollarTier
+             [ :order, :soft_dollar_tier_name,         :string_not_null ],
+             [ :order, :soft_dollar_tier_value,        :string_not_null ],
+             [ :order, :soft_dollar_tier_display_name, :string_not_null ],
+             [ :order, :cash_qty,  :decimal ],
+             [ :order, :dont_use_auto_price_for_hedge,   :bool ],
+             [ :order, :is_O_ms_container,               :bool ],
+             [ :order, :discretionary_up_to_limit_price, :bool ],
+             [ :order, :use_price_management_algo,       :bool ],
+             [ :order, :duration,                        :int ],
+             [ :order, :post_to_ats,                     :int ],
+             [ :order, :auto_cancel_parent,              :bool ]
+         # not implemented now > Server Version 170
+         # PEGBEST_PEGMID_OFFSETS:
+         # [:order, :min_trade_qty, :int ],
+         # [:order, :min_compete_size, :int ],
+         # [:order, :compete_against_best_offset, :decimal],
+         # [:order, :mid_offset_at_whole, :decimal ],
+         # [:order, :mid_offset_at_half, :decimal ]
+         # not implemented now > Server Version 183
+         # [:order, :customer_account, :string]
+         # not implemented now > Server Version 184
+         # [:order, :professional_customer, :bool]
+
+        end
+
+        # Check if given value was set by TWS to something vaguely "positive"
+        def filled? value
+#   puts "filled: #{value.class} --> #{value.to_s}"
+          case value
+            when String
+              (!value.empty?)# && (value != :none) && (value !='None')
+            when Float, Integer, BigDecimal
+              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

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

@@ -0,0 +1,85 @@
+module IB
+  module Messages
+    module Incoming
+
+      # :status - 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'.
+      #      As  of Api 9.72, no version is given anymore
+      #
+      OrderStatus = def_message [3, 0],
+                                [:order_state, :local_id, :int],
+                                [:order_state, :status, :string],
+                                [:order_state, :filled, :decimal],
+                                [:order_state, :remaining, :decimal],
+                                [: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],
+        [:order_state, :market_cap_price, :decimal] 
+      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
+          order_state.to_human
+        end
+
+      end # class OrderStatus
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,47 @@
+module IB
+  module Messages
+    module Incoming
+
+
+      PortfolioValue = def_message [7, 8], ContractMessage,
+            [:contract, :contract], # read standard-contract
+            [:portfolio_value, :position, :decimal],
+            [:portfolio_value,:market_price, :decimal],
+            [:portfolio_value,:market_value, :decimal],
+            [:portfolio_value,:average_cost, :decimal],
+            [:portfolio_value,:unrealized_pnl, :decimal], # May be nil!
+            [:portfolio_value,:realized_pnl, :decimal], #   May be nil!
+            [:account, :string]
+
+
+        class PortfolioValue
+
+
+          def to_human
+        # "<PortfolioValue: #{contract.to_human} #{portfolio_value}>"
+            portfolio_value.to_human
+          end
+          def portfolio_value
+            unless @portfolio_value.present?
+              @portfolio_value =  IB::PortfolioValue.new   @data[:portfolio_value]
+              @portfolio_value.contract = contract
+              @portfolio_value.account =  account
+            end
+            @portfolio_value # return_value
+          end
+
+          def account_name
+            @account_name =  @data[:account]
+          end
+
+#         alias :to_human :portfolio_value
+        end # PortfolioValue
+
+
+
+
+
+
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,21 @@
+module IB
+  module Messages
+    module Incoming
+
+      PositionData =
+        def_message( [61,3] , ContractMessage,
+          [:account, :string],
+          [:contract, :contract], # read standard-contract 
+#                                  [ con_id, symbol,. sec_type, expiry, strike, right, multiplier,
+                                   # primary_exchange, currency, local_symbol, trading_class ] 
+          [:position, :decimal],   # changed from int after Server Vers. MIN_SERVER_VER_FRACTIONAL_POSITIONS
+          [:price, :decimal]
+                   ) do 
+#        def to_human
+          "<PositionValue: #{account} ->  #{contract.to_human} ( Amount #{position}) : Market-Price #{price} >"
+        end
+
+
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,15 @@
+module IB
+  module Messages
+    module Incoming
+
+
+      PositionsMulti =  def_message( 71, ContractMessage,
+                                    [ :request_id, :int ],
+                                    [ :account, :string ],
+                                    [:contract, :contract], # read standard-contract
+          [ :position, :decimal],   # changed from int after Server Vers. MIN_SERVER_VER_FRACTIONAL_POSITIONS
+          [ :average_cost, :decimal],
+          [ :model_code, :string ])
+    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_date],
+                                [: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/receive_fa.rb

@@ -0,0 +1,30 @@
+module IB
+  module Messages
+    module Incoming
+
+      extend Messages # def_message macros
+
+
+      # Receives previously requested FA configuration information from TWS.
+      ReceiveFA =
+          def_message 16, [:type, :int], # type of Financial Advisor configuration data
+                      #                    being received from TWS. Valid values include:
+                      #                    1 = GROUPS, 2 = PROFILE, 3 = ACCOUNT ALIASES
+                      [:xml, :xml] # XML string with requested FA configuration information.
+
+        class ReceiveFA
+          def accounts
+            if( a= xml[:ListOfAccountAliases][:AccountAlias]).is_a? Array
+              a.map{|x| Account.new x }
+            elsif a.is_a? Hash      ## only one account (soley financial advisor)
+              [ Account.new( a ) ]
+            end
+          end
+
+          def to_human
+            "<FA: #{accounts.map(&:to_human).join(" - ")}>"
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+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
+        using IB::Support  # extended Array-Class  from abstract_message
+
+        def load
+          super
+
+          @results = Array.new(@data[:count]) do |_|
+            {:rank => buffer.read_int,
+             :contract =>
+                 Contract.build(
+                     :con_id => buffer.read_int,
+                     :symbol => buffer.read_string,
+                     :sec_type => buffer.read_string,
+                     :expiry => buffer.read_string,
+                     :strike => buffer.read_decimal,
+                     :right => buffer.read_string,
+                     :exchange => buffer.read_string,
+                     :currency => buffer.read_string,
+                     :local_symbol => buffer.read_string,
+                     :contract_detail =>
+                         IB::ContractDetail.new(
+                             :market_name => buffer.read_string,
+                             :trading_class => buffer.read_string)),
+             :distance => buffer.read_string,
+             :benchmark => buffer.read_string,
+             :projection => buffer.read_string,
+             :legs => buffer.read_string,
+            }
+          end
+        end
+      end # ScannerData
+
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,77 @@
+module IB
+  module Messages
+    module Incoming
+      extend Messages # def_message macros
+
+      TickByTick =  def_message [99, 0], [:ticker_id, :int ],
+      [ :tick_type, :int],
+      [ :time, :int_date ]
+
+      ## error messages: (10189) "Failed to request tick-by-tick data:Historical data request pacing violation"
+      #
+      class TickByTick
+        using IB::Support  # extended Array-Class  from abstract_message
+        def resolve_mask
+          @data[:mask].present? ? [ @data[:mask] & 1 , @data[:mask] & 2  ] : []
+        end
+
+        def load
+          super
+          case @data[:tick_type ]
+                      when 0
+                        # do nothing
+                      when 1, 2 # Last, AllLast
+              load_map  [ :price, :decimal ]  ,
+                        [ :size, :int ] ,
+                        [ :mask, :int ] ,
+                        [ :exchange, :string ],
+                        [ :special_conditions, :string ]
+                      when 3  # bid/ask
+              load_map  [ :bid_price, :decimal ],
+                        [ :ask_price, :decimal],
+                        [ :bid_size, :int ],
+                        [ :ask_size, :int] ,
+                        [ :mask, :int  ]
+                      when 4
+              load_map  [ :mid_point, :decimal ]
+                      end
+
+          @out_labels = case @data[ :tick_tpye ]
+                      when 1, 2
+                        [ "PastLimit", "Unreported" ]
+                        when 3
+                        [ "BitPastLow", "BidPastHigh" ]
+                        else
+                          []
+                        end
+        end
+        def to_human
+          "< TickByTick:" + case @data[ :tick_type ]
+          when 1,2
+            "(Last) #{size} @ #{price} [#{exchange}] "
+          when 3
+            "(Bid/Ask) #{bid_size} @ #{bid_price} / #{ask_size } @ #{ask_price} "
+          when 4
+            "(Midpoint)  #{mid_point } "
+          else
+            ""
+          end +  @out_labels.zip(resolve_mask).join( "/" )
+        end
+
+        [:price, :size, :mask, :exchange, :specialConditions, :bid_price, :ask_price, :bid_size, :ask_size, :mid_point].each do |name|
+          define_method name do
+            @data[name]
+          end
+        end
+      # def method_missing method, *args
+      #   if @data.keys.include? method
+      #     @data[method]
+      #   else
+      #     error "method #{method} not known"
+      #   end
+      # end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,18 @@
+module IB
+  module Messages
+    module Incoming
+      extend Messages # def_message macros
+
+
+      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]
+    end
+  end
+end