ib-api 10.33.1

data/models/ib/contract.rb

@@ -0,0 +1,411 @@
+module IB
+  class Contract <  IB::Base
+    include BaseProperties
+
+    # Fields are Strings unless noted otherwise
+    prop :con_id, # int: The unique contract identifier.
+      :currency, # Only needed if there is an ambiguity, e.g. when SMART exchange
+      #            and IBM is being requested (IBM can trade in GBP or USD).
+
+      :legs_description, # received in OpenOrder for all combos
+      :under_comp,  #  for delta neutral combos
+
+      :sec_type, # Security type. Valid values are: SECURITY_TYPES
+
+      :sec_id => :sup, # Unique identifier of the given secIdType.
+
+      :sec_id_type => :sup, # Security identifier, when querying contract details or
+      #               when placing orders. Supported identifiers are:
+      #               -  ISIN (Example: Apple: US0378331005)
+      #               -  CUSIP (Example: Apple: 037833100)
+      #               -  SEDOL (6-AN + check digit. Example: BAE: 0263494)
+      #               -  RIC (exchange-independent RIC Root and exchange-
+      #                  identifying suffix. Ex: AAPL.O for Apple on NASDAQ.)
+
+      :symbol => :s, # This is the symbol of the underlying asset.
+      :local_symbol => :s, # Local exchange symbol of the underlying asset
+      :trading_class => :s,
+      # Future/option contract multiplier (only needed when multiple possibilities exist)
+      :multiplier => :d,
+
+      :strike => :f, # double: The strike price.
+      :expiry => :s, # The expiration date. Use the format YYYYMM or YYYYMMDD
+      :last_trading_day =>  :s, # the tws returns the last trading day in Format YYYYMMMDD hh:mm
+        # which may differ from the expiry 
+      :exchange => :sup, # The order destination, such as Smart.
+      :primary_exchange => :sup, # Non-SMART exchange where the contract trades.
+      :include_expired => :bool, # When true, contract details requests and historical
+      #         data queries can be performed pertaining to expired contracts.
+      #         Note: Historical data queries on expired contracts are
+      #         limited to the last year of the contracts life, and are
+      #         only supported for expired futures contracts.
+      #         This field can NOT be set to true for orders.
+
+
+      # Specifies a Put or Call. Valid input values are: P, PUT, C, CALL
+    :right => {
+      :set => proc { |val|
+        self[:right] =
+        case val.to_s.upcase
+        when 'NONE', '', '0', '?'
+          ''
+        when 'PUT', 'P'
+          'P'
+        when 'CALL', 'C'
+          'C'
+        else
+          val
+        end
+      },
+      :validate => {:format => {:with => /\Aput$|^call$|^none\z/,
+                                :message => "should be put, call or none"}}
+    }
+
+    attr_accessor :description # NB: local to ib, not part of TWS.
+
+    ### Associations
+    has_many :misc   # multi purpose association
+    has_many :orders # Placed for this Contract
+    has_many :portfolio_values
+
+    has_many :bars # Possibly representing trading history for this Contract
+
+    has_one :contract_detail # Volatile info about this Contract
+
+    # For Contracts that are part of BAa ## leg is now a method of contract
+#   has_one :leg #, :class_name => 'ComboLeg', :foreign_key => :leg_contract_id
+   # has_one :combo, :class_name => 'Contract', :through => :leg
+
+    # for Combo/BAG Contracts that contain ComboLegs
+    has_many :combo_legs#, :foreign_key => :combo_id
+ #   has_many :leg_contracts, :class_name => 'Contract', :through => :combo_legs
+#    alias legs combo_legs
+ #   alias legs= combo_legs=
+
+  #    alias combo_legs_description legs_description
+  #  alias combo_legs_description= legs_description=
+
+  # for Delta-Neutral Combo Contracts
+      has_one :underlying
+    alias under_comp underlying
+    alias under_comp= underlying=
+
+
+      ### Extra validations
+      validates_inclusion_of :sec_type, :in => CODES[:sec_type].keys,
+      :message => "should be valid security type"
+
+    validates_format_of :expiry, :with => /\A\d{6}$|^\d{8}$|\A\z/,
+      :message => "should be YYYYMM or YYYYMMDD"
+
+    validates_format_of :primary_exchange, :without => /SMART/,
+      :message => "should not be SMART"
+
+    validates_format_of :sec_id_type, :with => /ISIN|SEDOL|CUSIP|RIC|\A\z/,
+      :message => "should be valid security identifier"
+
+    validates_numericality_of :multiplier, :strike, :allow_nil => true
+
+    def default_attributes  # :nodoc:
+      super.merge :con_id => 0,
+        :strike => "",
+        :right => :none, # Not an option
+       # :exchange => 'SMART',
+        :include_expired => false
+    end
+
+
+#    This returns an Array of data from the given contract and is used to represent
+#    contracts in outgoing messages.
+#
+#    Different messages serialize contracts differently. Go figure.
+#
+#    Note that it does NOT include the combo legs.
+#    serialize :option, :con_id, :include_expired, :sec_id
+#
+#    18/1/18: serialise always includes con_id
+
+    def serialize *fields  # :nodoc:
+      print_default = ->(field, default="") { field.blank? ? default : field }
+      [(con_id.present? && !con_id.is_a?(Symbol) && con_id.to_i > 0 ? con_id : ""),
+       print_default[symbol],
+       print_default[self[:sec_type]],
+       ( fields.include?(:option) ?
+       [ print_default[expiry],
+      ##  a Zero-Strike-Option  has to be defined with  «strike: -1 »
+         strike.present? && ( strike.is_a?(Numeric) && !strike.zero? && strike > 0 )  ?  strike : strike<0 ?  0 : "",
+         print_default[self[:right]],
+         print_default[multiplier]] : nil ),
+       print_default[exchange],
+       ( fields.include?(:primary_exchange) ? print_default[primary_exchange]   : nil ) ,
+       print_default[currency],
+       print_default[local_symbol],
+       ( fields.include?(:trading_class) ? print_default[trading_class] : nil ),
+       ( fields.include?(:include_expired) ? print_default[include_expired,0] : nil ),
+       ( fields.include?(:sec_id_type) ? [print_default[sec_id_type], print_default[sec_id]] : nil )
+       ].flatten.compact
+    end
+
+    # serialize contract
+    # con_id. sec_type, expiry, strike, right, multiplier exchange, primary_exchange, currency, local_symbol, include_expired
+    # other fields on demand
+    def serialize_long *fields # :nodoc:
+      serialize :option, :include_expired, :primary_exchange, :trading_class, *fields
+    end
+
+    # serialize contract
+    # con_id. sec_type, expiry, strike, right, multiplier, exchange, primary_exchange, currency, local_symbol
+    # other fields on demand
+    # acutal used by place_order, request_marketdata, request_market_depth, exercise_options
+    def serialize_short *fields  # :nodoc:
+      serialize :option, :trading_class, :primary_exchange, *fields
+    end
+
+    # same as :serialize_short, omitting primary_exchange
+      # used by      RequestMarketDepth
+    def serialize_supershort *fields  # :nodoc:
+      serialize :option, :trading_class,  *fields
+    end
+
+    # Serialize under_comp parameters: EClientSocket.java, line 471
+    def serialize_under_comp *args   # :nodoc:
+      under_comp ? [true] + under_comp.serialize : [false]
+    end
+
+    # Defined in Contract, not BAG subclass to keep code DRY
+    def serialize_legs *fields    # :nodoc:
+      case
+      when !bag?
+       []
+      when combo_legs.empty?
+        [0]
+      else
+        [combo_legs.size, combo_legs.map{|x| x.serialize :extended} ]
+      end
+    end
+
+
+
+    # This produces a string uniquely identifying this contract, in the format used
+    # for command line arguments in the IB-Ruby examples. The format is:
+    #
+    #    symbol:sec_type:expiry:strike:right:multiplier:exchange:primary_exchange:currency:local_symbol
+    #
+    # Fields not needed for a particular security should be left blank
+    # (e.g. strike and right are only relevant for options.)
+    #
+    # For example, to query the British pound futures contract trading on Globex
+    # expiring in September, 2008, the string is:
+    #
+    #    GBP:FUT:200809:::62500:GLOBEX::USD:
+    def serialize_ib_ruby
+      serialize_long.join(":")
+    end
+
+    # extracts essential attributes of the contract,
+    # and returns a new contract. Used for comparism of equality of contracts
+    #
+    # the link to contract-details is __not__ maintained.
+    def  essential
+
+      the_attributes = [ :sec_type, :symbol , :con_id,   :exchange, :right,
+                    :currency, :expiry,  :strike,   :local_symbol, :last_trading_day,
+                :multiplier,  :primary_exchange, :trading_class, :description ]
+      new_contract= self.class.new( invariant_attributes.select{|k,_| the_attributes.include? k }
+                                                        .transform_values{|v| v.is_a?(Numeric)? v : v.to_s.upcase } )
+      new_contract[:description] = if @description.present?
+                                     @description
+                                   elsif contract_detail.present?
+                                     contract_detail.long_name
+                                   else
+                                     ""
+                                   end
+      new_contract # return contract
+    end
+
+
+    # creates a new Contract substituting attributes by the provided key-value pairs.
+    #
+    # for convenience
+    # con_id, local_symbol and last_trading_day are resetted,
+    # the link to contract-details is savaged
+    #
+    # Example
+    #   ge =  Stock.new( symbol: :ge).verify.first
+    #   f = ge.merge symbol: :f
+    #
+    #   c =  Contract.new( con_id: 428520002,  exchange: 'Globex')
+    #puts c.verify.as_table
+#┌────────┬────────┬───────────┬──────────┬──────────┬────────────┬───────────────┬───────┬────────┬──────────┐
+#│        │ symbol │ con_id    │ exchange │ expiry   │ multiplier │ trading-class │ right │ strike │ currency │
+#╞════════╪════════╪═══════════╪══════════╪══════════╪════════════╪═══════════════╪═══════╪════════╪══════════╡
+#│ Future │ NQ     │ 428520002 │  GLOBEX  │ 20210917 │     20     │      NQ       │       │        │   USD    │
+#└────────┴────────┴───────────┴──────────┴──────────┴────────────┴───────────────┴───────┴────────┴──────────┘
+    # d= c.merge symbol: :es, trading_class: '', multiplier: 50
+    # puts d.verify.as_table
+#┌────────┬────────┬───────────┬──────────┬──────────┬────────────┬───────────────┬───────┬────────┬──────────┐
+#│        │ symbol │ con_id    │ exchange │ expiry   │ multiplier │ trading-class │ right │ strike │ currency │
+#╞════════╪════════╪═══════════╪══════════╪══════════╪════════════╪═══════════════╪═══════╪════════╪══════════╡
+#│ Future │ ES     │ 428520022 │  GLOBEX  │ 20210917 │     50     │      ES       │       │        │   USD    │
+#│ Future │ ES     │ 446091461 │  GLOBEX  │ 20211217 │     50     │      ES       │       │        │   USD    │
+#│ Future │ ES     │ 461318816 │  GLOBEX  │ 20220318 │     50     │      ES       │       │        │   USD    │
+#│ Future │ ES     │ 477836957 │  GLOBEX  │ 20220617 │     50     │      ES       │       │        │   USD    │
+#│ Future │ ES     │ 495512551 │  GLOBEX  │ 20221216 │     50     │      ES       │       │        │   USD    │
+#│ Future │ ES     │ 495512552 │  GLOBEX  │ 20231215 │     50     │      ES       │       │        │   USD    │
+#│ Future │ ES     │ 495512557 │  GLOBEX  │ 20241220 │     50     │      ES       │       │        │   USD    │
+#│ Future │ ES     │ 495512563 │  GLOBEX  │ 20251219 │     50     │      ES       │       │        │   USD    │
+#│ Future │ ES     │ 495512566 │  GLOBEX  │ 20220916 │     50     │      ES       │       │        │   USD    │
+#│ Future │ ES     │ 495512569 │  GLOBEX  │ 20230616 │     50     │      ES       │       │        │   USD    │
+#│ Future │ ES     │ 495512572 │  GLOBEX  │ 20230317 │     50     │      ES       │       │        │   USD    │
+#│ Future │ ES     │ 497222760 │  GLOBEX  │ 20230915 │     50     │      ES       │       │        │   USD    │
+#└────────┴────────┴───────────┴──────────┴──────────┴────────────┴───────────────┴───────┴────────┴──────────┘
+
+    def merge **new_attributes
+
+      resetted_attributes = [:con_id, :local_symbol, :contract_detail]
+      ## last_trading_day / expiry needs special treatment
+      resetted_attributes << :last_trading_day if  new_attributes.keys.include? :expiry
+      self.class.new attributes.reject{|k,_| resetted_attributes.include? k}.merge(new_attributes)
+    end
+
+    # Contract comparison
+
+    def == other  # :nodoc:
+#      a = ->(e){ e.essential.invariant_attributes.select{|y,_| ![:description, :include_expired, :con_id, :trading_class, :primary_exchange].include? y} }
+      return true if self.con_id == other.con_id
+#      a.call(self) == a.call(other)
+      common_keys = self.invariant_attributes.keys & other.invariant_attributes.keys
+      common_keys.all? do |key|
+          value1 = attributes[key]
+          value2 = other.attributes[key]
+          next true if value1 == value2
+          value1.to_i.zero? || value2.to_i.zero? rescue true
+      end
+    end
+
+#    def to_s
+#      "<Contract: " + instance_variables.map do |key|
+#        value = send(key[1..-1])
+#        " #{key}=#{value} (#{value.class}) " unless value.blank?
+#      end.compact.join(',') + " >"
+#    end
+
+    def to_human
+      "<Contract: " +
+        [symbol,
+         sec_type,
+         (expiry == '' ? nil : expiry),
+         (right == :none ? nil : right),
+         (strike == 0 ? nil : strike),
+         exchange,
+         currency
+         ].compact.join(" ") + ">"
+    end
+
+    alias to_s to_human
+
+    # Testing for type of contract:
+    # depreciated :  use is_a?(IB::Stock, IB::Bond, IB::Bag etc) instead
+    def bag?  #  :nodoc:
+      self[:sec_type] == 'BAG'
+    end
+
+    def bond?  #  :nodoc:
+
+      self[:sec_type] == 'BOND'
+    end
+
+    def stock? #  :nodoc:
+
+      self[:sec_type] == 'STK'
+    end
+
+    def option?  #  :nodoc:
+
+      self[:sec_type] == 'OPT'
+    end
+
+    def index?  #  :nodoc:
+
+      self[:sec_type] == 'IND'
+    end
+
+    def crypto?  #  :nodoc:
+
+      self[:sec_type] == 'CRYPTO'
+    end
+
+
+    def time_zone
+      if contract_detail.present? 
+        contract_detail.time_zone
+      else
+        case currency
+          when "EUR"
+            "MET"
+          when "AUD"
+            "Australia/NSW"
+          when "USD"
+            "US/Eastern"
+          else
+            "UTC"
+        end
+      end
+    end
+=begin
+From the release notes of TWS 9.50
+
+Within TWS and Mosaic, we use the last trading day and not the actual expiration date for futures, options and futures options contracts. To be more accurate, all fields and selectors throughout TWS that were labeled Expiry or Expiration have been changed to Last Trading Day. Note that the last trading day and the expiration date may be the same or different dates.
+
+In many places, such as the OptionTrader, Probability Lab and other options/futures tools, this is a simple case of changing the name of a field to Last Trading Day. In other cases the change is wider-reaching. For example, basket files that include derivatives were previously saved using the Expiry header. When you try to import these legacy .csv files, you will now receive a message requiring that you change this column title to LastTradingDayorContractMonth before the import will be accepted. New basket files that include derivatives will use this correct header. Additionally, this new field serves two functions. If you use the format YYYYMMDD, we understand you are identifying the last trading day for a contract. If you use the format YYYYMM, we understand you are identifying the contract month.
+
+In places where these terms are used to indicate a concept, we have left them as Expiry or Expiration. For example in the Option Chain settings where we allow you to "Load the nearest N expiries" we have left the word expiries. Additionally, the Contract Description window will show both the Last Trading Date and the Expiration Date. Also in cases where it's appropriate, we have replaced Expiry or Expiration with Contract Month.
+
+=end
+
+
+# IB-ruby uses expiry to query Contracts.
+#
+# The response from the TWS is stored in 'last_trading_day' (Contract) and 'real_expiration_data' (ContractDetails)
+#
+# However, after querying a contract, 'expiry' ist overwritten by 'last_trading_day'. The original 'expiry'
+# is still available through 'attributes[:expiry]'
+
+    def expiry
+      if self.last_trading_day.present?
+        last_trading_day.gsub(/-/,'')
+      else
+        @attributes[:expiry]
+      end
+    end
+
+
+# is read by Account#PlaceOrder to set requirements for contract-types, as NonGuaranteed for stock-spreads
+    def order_requirements
+      Hash.new
+    end
+
+
+    def table_header( &b )
+      if block_given?
+      [ yield(self) , 'symbol',  'con_id', 'exchange', 'expiry','multiplier', 'trading-class' , 'right', 'strike', 'currency' ]
+      else
+      [ '', 'symbol',  'con_id', 'exchange', 'expiry','multiplier', 'trading-class' , 'right', 'strike', 'currency' ]
+      end
+    end
+
+    def table_row
+      [ self.class.to_s.demodulize, symbol,
+        { value: con_id.zero? ? '' : con_id , alignment: :right},
+         { value: exchange, alignment: :center},
+         expiry,
+         { value: multiplier.nil? || multiplier.zero??  "" : multiplier, alignment: :center},
+         { value: trading_class.nil? ? "" : trading_class, alignment: :center},
+         { value: right.nil? || right == :none ? "": right, alignment: :center },
+         { value: strike.nil? || strike.zero? ? "": strike, alignment: :right},
+         { value: currency, alignment: :center} ]
+
+    end
+  end # class Contract
+end # module IB
+

data/models/ib/contract_detail.rb

@@ -0,0 +1,118 @@
+module IB
+
+  # Additional Contract properties (volatile, therefore extracted)
+  class ContractDetail < IB::Base
+    include BaseProperties
+
+    # All fields Strings, unless specified otherwise:
+    prop :market_name, # The market name for this contract.
+      :trading_class, # The trading class name for this contract.
+      :min_tick, # double: The minimum price tick.
+      :price_magnifier, # int: Allows execution and strike prices to be reported
+      #                 consistently with market data, historical data and the
+      #                 order price: Z on LIFFE is reported in index points, not GBP.
+
+      :order_types, #       The list of valid order types for this contract.
+      :valid_exchanges, #   The list of exchanges this contract is traded on.
+      :under_con_id, # int: The underlying contract ID.
+      :long_name, #         Descriptive name of the asset.
+      :contract_month, #    The contract month of the underlying futures contract.
+
+      :agg_group,
+      :under_symbol,
+      :under_sec_type,
+      :market_rule_ids,
+      :real_expiration_date,
+
+
+      # For Bonds only
+      :valid_next_option_date,
+      :valid_next_option_type,
+      :valid_next_option_partial,
+
+      # The industry classification of the underlying/product:
+      :industry, #    Wide industry. For example, Financial.
+      :category, #    Industry category. For example, InvestmentSvc.
+      :subcategory, # Subcategory. For example, Brokerage.
+      [:time_zone, :time_zone_id], # Time zone for the trading hours (e.g. EST)
+      :trading_hours, # The trading hours of the product. For example:
+      #                 20090507:0700-1830,1830-2330;20090508:CLOSED.
+      :liquid_hours, #  The liquid trading hours of the product. For example,
+      #                 20090507:0930-1600;20090508:CLOSED.
+
+      # To support products in Australia which trade in non-currency units, the following
+      # attributes have been added to Execution and Contract Details objects:
+      :ev_rule, # evRule - String contains the Economic Value Rule name and optional argument,
+      #          separated by a colon. Examle: aussieBond:YearsToExpiration=3.
+      #          When the optional argument not present, the value will be followed by a colon.
+      [:ev_multiplier, :ev_multipler], # evMultiplier - double, tells you approximately
+      #          how much the market value of a contract would change if the price were
+      #          to change by 1. It cannot be used to get market value by multiplying
+      #          the price by the approximate multiplier.
+
+      :sec_id_list, # Array with multiple Security ids
+      # MD Size Multiplier. Returns the size multiplier for values returned to tickSize from a market data request. Generally 100 for US stocks and 1 for other instruments.
+      :md_size_multiplier,
+#
+      # BOND values:
+      :cusip, # The nine-character bond CUSIP or the 12-character SEDOL.
+      :ratings, # Credit rating of the issuer. Higher rating is less risky investment.
+      #           Bond ratings are from Moody's and S&P respectively.
+      :desc_append, # Additional descriptive information about the bond.
+      :bond_type, #   The type of bond, such as "CORP."
+      :coupon_type, # The type of bond coupon.
+      :coupon, # double: The interest rate used to calculate the amount you
+      #          will receive in interest payments over the year. default 0
+      :maturity, # The date on which the issuer must repay bond face value
+      :issue_date, # The date the bond was issued.
+      :next_option_date, # only if bond has embedded options.
+      :next_option_type, # only if bond has embedded options.
+      :notes, # Additional notes, if populated for the bond in IB's database
+      :stock_type,   # new Version 10.12 -->  common
+      :min_size,    # new Version 10.12
+      :size_increment,   # new Version 10.12
+      :suggested_size_increment,  # new Version 10.12
+      :callable => :bool, # Can be called by the issuer under certain conditions.
+      :puttable => :bool, # Can be sold back to the issuer under certain conditions
+      :convertible => :bool, # Can be converted to stock under certain conditions.
+      :next_option_partial => :bool # # only if bond has embedded options.
+
+      # Extra validations
+      validates_format_of :time_zone, :with => /\A\w{3}\z/, :message => 'should be XXX'
+
+    serialize :sec_id_list, Hash
+
+    belongs_to :contract
+    alias summary contract
+    alias summary= contract=
+
+    def default_attributes
+      super.merge :coupon => 0.0,
+        :under_con_id => 0,
+        :min_tick => 0,
+        :ev_multipler => 0,
+        :sec_id_list => Hash.new,
+        :callable => false,
+        :puttable => false,
+        :convertible => false,
+        :next_option_partial => false
+    end
+
+    def to_human
+      ret = "<ContractDetails  #{long_name}, "
+      ret << "--> #{market_name}, " if market_name.present?
+      ret << "/C/ #{category}, /I/ #{industry} /SC/ #{subcategory}, " if category.present?
+      ret << "Underlying:#{under_symbol}[#{under_sec_type}](#{under_con_id}), " unless under_con_id.zero?
+      ret << "ev_multiplier:#{ev_multiplier}, " if ev_multiplier.present?
+      ret << "convertible:#{convertible}, " if convertible
+      ret << "coupon:#{coupon}, " if coupon.present?  && coupon > 0 
+      ret << "md_size_multiplier:#{md_size_multiplier}, min_tick:#{min_tick}, "
+      ret << "next_option_partial:#{next_option_partial}, " if next_option_partial.present?
+      ret << "price_magnifier:#{price_magnifier}, " 
+      ret << "puttable:#{puttable}, " if puttable.present? 
+      ret << "sec_id-list:#{sec_id_list}, " unless sec_id_list.empty?
+      ret <<"valid exchanges: #{ valid_exchanges}; order types: #{order_types} >"
+    end
+
+  end # class ContractDetail
+end # module IB

data/models/ib/execution.rb

@@ -0,0 +1,67 @@
+module IB
+
+  # This is IB Order execution report.
+  class Execution < IB::Base
+    include BaseProperties
+
+    belongs_to :order
+
+    prop :local_id, #   int: order id. TWS orders have a fixed order id of 0.
+      :client_id, #     int: client id. TWS orders have a fixed client id of 0.
+      :perm_id, #       int: TWS id used to identify orders over TWS sessions
+      :exec_id, #       String: Unique order execution id over TWS sessions.
+      :time, #         # TODO: convert into Time object?
+      #                 String: The order execution time.
+      :exchange, #      String: Exchange that executed the order.
+      :order_ref, #     String: Same order_ref as in corresponding Order
+      :price, #         double: The order execution price.
+      :average_price, # double: Used in regular trades, combo trades and legs of the combo.
+      :ev_rule, #       String: Australian products only
+      :ev_multiplier, # double: Australian products onlyA
+      :model_code,
+      :last_liquidity,
+
+      [:quantity, :shares], #       int: The number of shares filled.
+      :cumulative_quantity, # int: Used in regular trades, combo trades and legs of combo
+      :liquidation => :bool, # This position is liquidated last should the need arise.
+      [:account_name, :account_number] => :s, # The customer account number.
+      [:side, :action] => PROPS[:side] # Was the transaction a buy or a sale: BOT|SLD
+
+    # Extra validations
+    validates_numericality_of :quantity, :cumulative_quantity, :price, :average_price
+    validates_numericality_of :local_id, :client_id, :perm_id, :only_integer => true
+
+    def default_attributes
+      super.merge :local_id => 0,
+        :client_id => 0,
+        :quantity => 0,
+        :price => 0,
+        :perm_id => 0,
+        :liquidation => false
+    end
+
+    # Comparison
+    def == other
+      super(other) ||
+        other.is_a?(self.class) &&
+        perm_id == other.perm_id &&
+        local_id == other.local_id && # ((p __LINE__)||true) &&
+        client_id == other.client_id &&
+        exec_id == other.exec_id &&
+        time == other.time &&
+        exchange == other.exchange &&
+        order_ref == other.order_ref &&
+        side == other.side
+      # TODO: || compare all attributes!
+    end
+
+    def to_human
+      "<Execution: #{time} #{side} #{quantity} at #{price} on #{exchange}, " +
+        "cumulative #{cumulative_quantity} at #{average_price}, " +
+        "ids #{local_id}/#{perm_id}/#{exec_id}>"
+    end
+
+    alias to_s to_human
+
+  end # Execution
+end # module IB

data/models/ib/forex.rb

@@ -0,0 +1,12 @@
+module IB
+  class Forex  < IB::Contract
+    validates_format_of :sec_type, :with => /\Aforex\z/,
+      :message => "should be a Currency-Pair"
+    def default_attributes
+      # Base-currency: USD
+      super.merge :sec_type => :forex, currency:'USD', exchange:'IDEALPRO'
+    end
+
+  end
+  end
+

data/models/ib/future.rb

@@ -0,0 +1,64 @@
+module IB
+  class Future  < Contract
+    validates_format_of :sec_type, :with => /\Afuture\z/,
+      :message => "should be a Future"
+    def default_attributes
+      super.merge :sec_type => :future, currency:'USD'
+    end
+    def to_human
+      "<Future: " + [symbol, expiry, currency].join(" ") + ">"
+    end
+
+
+
+    # get the next (regular) expiry of the contract
+    #
+    # fetches for real contracts if verify is available
+    #
+    def next_expiry d =  Date.today
+      exp = self.class.next_expiry d
+      if IB::Connection.current.plugins.include? 'verify'
+        self.expiry = exp[0..-3]
+        verify.sort_by{| x | x.last_trading_day}
+              .find_all{| y | y.expiry <= exp }
+              .first
+      else
+        exp
+      end
+    end
+    class << self
+
+
+      # This returns the next
+      # quarterly expiration month after the current month.
+      #
+      # IB::Future.next_expiry returns the next quaterly expiration
+      # IB::Option.next_expiry returns the next monthly expiration
+      #
+      #
+      #
+      def next_expiry d=Date.today, type: :quarter
+        next_quarter_day = ->(year, month) do
+          base_date = Date.new(year, month)
+          base_wday  =  base_date.wday
+          base_date + ( 5 > base_wday ? 5 - base_wday : 7 - base_wday + 5 ) +  14
+        end
+        next_quarter_day[ next_quarter_year(d), next_quarter_month(d) ].strftime("%Y%m%d")
+#  /retired/        "#{ next_quarter_year(time) }#{ sprintf("%02d", next_quarter_month(time)) }"
+      end
+
+      private
+      # Find the next front month of quarterly futures.
+      # N.B. This will not work as expected during the front month before expiration, as
+      # it will point to the next quarter even though the current month is still valid!
+      def next_quarter_month d
+        [3, 6, 9, 12].find { |month| month > d.month } || 3 # for December, next March
+      end
+
+      def next_quarter_year d
+        next_quarter_month(d) < d.month ? d.year + 1 : d.year
+      end
+    end
+  end
+  end
+