ib-api 10.33.1

data/plugins/ib/spread-prototypes/strangle.rb

@@ -0,0 +1,93 @@
+module IB
+
+    module  Strangle
+      
+      extend SpreadPrototype
+      class << self
+
+
+#  Fabricate a Strangle from a Master-Option
+#  -----------------------------------------
+#  If one Leg is known, the other is build by flipping the right and adjusting the strike by distance
+#
+#   Call with
+#   IB::Strangle.fabricate an_option, numeric_value
+      def fabricate master, distance
+
+        flip_right = ->(the_right){  the_right == :put ? :call : :put   }
+
+        error "Argument must be an option" unless [:option, :futures_option].include? master.sec_type
+
+
+        initialize_spread( master ) do | the_spread |
+          the_spread.add_leg master.verify.first
+          the_spread.add_leg master
+                             .essential
+                             .merge( right: flip_right[master.right],
+                                     strike: master.strike.to_f + distance.to_f ,
+                                     local_symbol: '',
+                                     con_id: 0 ) 
+                             .verify.first
+          error "Initialisation of Legs failed" if the_spread.legs.size != 2
+#          the_spread.description =  the_description( the_spread )
+        end
+      end
+
+
+#  Build  Strangle out of an Underlying
+#  -----------------------------------------
+#  Needed attributes: :strike, :expiry
+#
+#  Optional: :trading_class, :multiplier
+#
+#   Call with
+#   IB::Strangle.build from: IB::Contract, p:  a_value,  c:  a_value, expiry: yyyymm(dd)
+      def build from:,  p: nil, c: nil, expiry: nil, **fields
+        underlying = if from.is_a?  IB::Option
+                       p ||= from.strike
+                       c ||= from.strike
+                       expiry ||= from.expiry
+
+                       details =  from.verify.first.contract_detail
+                       IB::Contract.new(  con_id: details.under_con_id,
+                                        currency: from.currency,
+                                        exchange: from.exchange) .verify.first .essential
+                     else
+                       from
+                     end
+        kind = { :p => p, :c => c }
+        initialize_spread( underlying ) do | the_spread |
+          leg_prototype  = IB::Option.new from.attributes
+            .slice( :currency, :symbol, :exchange)
+            .merge(defaults)
+            .merge( expiry: expiry )
+            .merge( fields )
+
+          leg_prototype.sec_type = 'FOP' if underlying.is_a?(IB::Future)
+          the_spread.add_leg leg_prototype.merge( right: :put, strike: kind[:p] ).verify.first
+          the_spread.add_leg leg_prototype.merge( right: :call, strike: kind[:c] ).verify.first
+          error "Initialisation of Legs failed" if the_spread.legs.size != 2
+          the_spread.description =  the_description( the_spread )
+        end
+      end
+
+      def defaults
+      super.merge expiry: IB::Future.next_expiry
+      end
+
+
+      def requirements
+        super.merge p: "the strike of the put option",
+                    c: "the strike of the call option",
+                    expiry: "Expiry expressed as »yyyymm(dd)« (String or Integer) )"
+      end
+
+
+
+      def the_description spread
+        "<Strangle #{spread.symbol}(#{spread.legs.map(&:strike).join(",")})[#{Date.parse(spread.legs.first.last_trading_day).strftime("%b %Y")}]>"
+      end
+
+      end # class
+    end # module combo
+end  # module ib

data/plugins/ib/spread-prototypes/vertical.rb

@@ -0,0 +1,83 @@
+module IB
+
+    module  Vertical
+      
+      extend SpreadPrototype
+      class << self
+
+
+#  Fabricate a Vertical from a Master-Option
+#  -----------------------------------------
+#  If one Leg is known, the other is build by flipping the right and adjusting the strike by distance
+#
+#   Call with
+#   IB::Vertical.fabricate  an_option, buy: {another_strike},  (or) , :sell{another_strike}
+      def fabricate master, buy: 0, sell: 0
+
+        error "Argument must be an option" unless [:option, :futures_option].include? master.sec_type
+        error "Unable to fabricate Vertical. Either :buy or :sell must be specified " if buy.zero? && sell.zero?
+
+        buy =  master.strike if buy.zero?
+        sell =  master.strike if sell.zero?
+        initialize_spread( master ) do | the_spread |
+          the_spread.add_leg master.merge(strike: sell).verify.first, action: :sell
+          the_spread.add_leg master.merge(strike: buy).verify.first, action: :buy
+          error "Initialisation of Legs failed" if the_spread.legs.size != 2
+          the_spread.description =  the_description( the_spread )
+        end
+      end
+
+
+#  Build  Vertical out of an Underlying
+#  -----------------------------------------
+#  Needed attributes: :strikes (buy: strike1, sell: strike2), :expiry, right
+#
+#  Optional: :trading_class, :multiplier
+#
+#   Call with
+#   IB::Straddle.build from: IB::Contract, buy: a_strike,  sell: a_stike, right: {put or call}, expiry: yyyymmm(dd)
+      def build from:, **fields
+        underlying = if from.is_a?  IB::Option
+                       fields[:right] = from.right unless fields.key?(:right)
+                       fields[:sell] = from.strike unless fields.key(:sell)
+                       fields[:buy] = from.strike unless fields.key?(:buy)
+                       fields[:expiry] = from.expiry unless fields.key?(:expiry)
+                       fields[:trading_class] = from.trading_class unless fields.key?(:trading_class) || from.trading_class.empty?
+                       fields[:multiplier] = from.multiplier unless fields.key?(:multiplier) || from.multiplier.to_i.zero?
+                       details =  from.verify.first.contract_detail
+                       IB::Contract.new( con_id: details.under_con_id,
+                                        currency: from.currency,
+                                        exchange: from.exchange)
+                                       .verify.first
+                                       .essential
+                     else
+                       from
+                     end
+        kind = { :buy => fields.delete(:buy), :sell => fields.delete(:sell) }
+        error "Specification of :buy and :sell necessary, got: #{kind.inspect}" if kind.values.any?(nil)
+        initialize_spread( underlying ) do | the_spread |
+          leg_prototype  = Option.new underlying.attributes
+                              .slice( :currency, :symbol, :exchange)
+                              .merge(defaults)
+                              .merge( fields )
+          leg_prototype.sec_type = 'FOP' if underlying.is_a?(IB::Future)
+          the_spread.add_leg  leg_prototype.merge(strike: kind[:sell]).verify.first, action: :sell
+          the_spread.add_leg  leg_prototype.merge(strike: kind[:buy] ).verify.first, action: :buy
+          error "Initialisation of Legs failed" if the_spread.legs.size != 2
+          the_spread.description =  the_description( the_spread )
+        end
+      end
+
+      def defaults
+      super.merge expiry: IB::Future.next_expiry,
+                  right: :put
+      end
+
+
+      def the_description spread
+        x= [ spread.combo_legs.map(&:weight) , spread.legs.map( &:strike )].transpose
+        "<Vertical #{spread.symbol} #{spread.legs.first.right}(#{x.map{|w,strike| "#{w} :#{strike} "}.join( '|+|' )} )[#{Date.parse(spread.legs.first.last_trading_day).strftime("%b %Y")}]>"
+      end
+     end # class
+    end # module vertical
+end  # module ib

data/plugins/ib/spread-prototypes.rb

@@ -0,0 +1,70 @@
+=begin
+
+Plugin to automate the creation of common spreads
+
+   Straddle.build from: Contract, expiry:,   strike:
+   Strangle build from: Contract. expiry:,  p: , c:
+   Vertical.build from: Contract, expiry:, right: , buy: (a strike), sell: (a strike)
+   Calendar.build from: Contract. right:, :strike:, front: (an expiry), back: (an expiry)
+   Butterfly.build from: Contract, right:, strike: , expiry: ,  front: (long-option strike), back: (long option strike)
+
+   StockSpread.fabricate  symbol1, symbol2, ratio:[ n, m ]  # only for us-stocks
+
+=end
+
+module IB
+# Spreads are created in  two ways:
+#
+# (1) IB::Spread::{prototype}.build  from: {underlying},
+#                                    trading_class: (optional)
+#                                    {other specific attributes}
+#
+# (2) IB::Spread::{prototype}.fabcricate master: [one leg},
+#                                     {other specific attributes}
+#
+# They return a freshly instantiated Spread-Object
+#
+  module SpreadPrototype
+
+
+    def build from: , **fields
+    end
+
+
+    def initialize_spread ref_contract = nil, **attributes
+      error "Initializing of Spread failed – contract is missing" unless ref_contract.is_a?(IB::Contract)
+      # make sure that :exchange, :symbol and :currency are present
+      the_contract =  ref_contract.merge( **attributes ).verify.first
+      error "Underlying for Spread is not valid: #{ref_contract.to_human}" if the_contract.nil?
+      the_spread= IB::Spread.new  the_contract.attributes.slice( :exchange, :symbol, :currency )
+      error "Initializing of Spread failed – Underling is no Contract" if the_spread.nil?
+      yield the_spread if block_given?  # yield outside mutex controlled verify-environment
+      the_spread  # return_value
+    end
+
+    def requirements
+      {}
+    end
+
+    def defaults
+      {}
+    end
+
+    def optional
+      { }
+    end
+
+    def parameters
+      the_output = ->(var){ var.empty? ? "none" : var.map{|x| x.join(" --> ") }.join("\n\t: ")}
+
+      "Required : " + the_output[requirements] + "\n --------------- \n" +
+      "Optional : " + the_output[optional] + "\n --------------- \n" 
+
+    end
+  end
+    Connection.current.activate_plugin "verify"
+  [:straddle, :strangle, :vertical, :calendar, :"stock-spread", :butterfly].each do | pt |
+    Connection.current.activate_plugin "spread_prototypes/#{pt.to_s}"
+  end
+end
+

data/plugins/ib/symbols/abstract.rb

@@ -0,0 +1,136 @@
+module IB
+
+  # reopen the contract-class and add yml_file
+   class Contract
+
+  # Reading Contract-Defaults
+  #
+  # by default, the yml-file in the base-directory (ib-ruby) is used.
+  # This method can be overloaded to include a file from a different location
+  #
+  #  IB::Symbols::Stocks.wfc.yml_file
+  #   => "/home/ubuntu/workspace/ib-ruby/contract_config.yml"
+  #
+  def yml_file
+           File.expand_path('../../../../contract_config.yml',__FILE__ )
+        end
+   end
+
+  module Symbols
+
+=begin
+Creates a Class and associates it with a filename
+
+raises an IB::Error in case of a conflict with existing class-names
+=end
+
+# set the Pathname to "ib-api/symbols" by default
+  @@dir= Pathname.new File.expand_path("../../../../symbols/", __FILE__ )
+  def self.set_origin directory
+    p = Pathname.new directory
+    @@dir = p if p.directory?
+  rescue Errno::ENOENT
+    error "Setting up origin for symbol-files --> Directory (#{directory}) does not exist"
+  end
+
+  def self.allocate_collection name  # name might be a string or a symbol
+    symbol_table = Module.new do
+      extend Symbols
+      extend Enumerable
+      def self.yml_file
+        @@dir + name.to_s.downcase.split("::").last.concat( ".yml" )
+      end
+
+      def self.each &b
+        contracts.values.each &b
+      end
+    end   # module new
+    name =  name.to_s.camelize.to_sym
+    the_collection = if Symbols.send  :const_defined?, name
+         Symbols.send :const_get, name
+         else
+         Symbols.const_set  name, symbol_table
+         end
+    if the_collection.is_a? Symbols
+      the_collection.send :read_collection if the_collection.all.empty?
+      the_collection # return_value
+    else
+      error "#{the_collection} is already a Class"
+      nil
+    end
+  end
+
+  def purge_collection
+    yml_file.delete
+    @contracts =  nil
+  end
+
+=begin
+cuts the Collection in `bunch_count` pieces. Each bunch is delivered to the block.
+
+Sleeps for `sleeping time` between processing bunches
+
+Returns count of created bunches
+=end
+  def bunch( bunch_count = 50 , sleeping_time = 1)
+    en = self.each
+    the_size =  en.size
+    i =  0 
+    loop do
+      the_start = i * bunch_count
+      the_end =  the_start + bunch_count
+      the_end = the_size -1 if the_end >= the_size
+      it  = the_start .. the_end
+      yield it.map{|x| en.next rescue nil}.compact
+      break if  the_end == the_size -1 
+      i+=1
+      sleep sleeping_time
+    end 
+     i -1  # return counts of bunches
+  end
+
+  def read_collection
+    if  yml_file.exist?
+      contracts.merge! YAML.unsafe_load_file yml_file rescue contracts
+    else
+       yml_file.open( "w"){}
+    end
+  end
+
+  def store_collection
+     yml_file.open( 'w' ){|f| f.write @contracts.to_yaml}
+  end
+
+  def add_contract symbol, contract
+    if symbol.is_a? String
+      symbol.to_sym
+    elsif symbol.is_a? Symbol
+      symbol
+    else
+      symbol.to_i
+    end
+  # ensure that evey Sybmol::xxx.yyy entry has a description
+    contract.description =  contract.to_human[1..-2] if contract.description.nil?
+    # overwrite contract if existing
+    contracts[ symbol ] = contract.essential
+    store_collection
+  end
+
+  def remove_contract symbol
+    @contracts.delete  symbol 
+    store_collection
+  end
+
+
+  def to_human
+    self.to_s.split("::").last
+  end
+
+
+
+  module Unspecified
+    extend Symbols
+  end
+
+  end # module Symbols
+end #  module IB

data/plugins/ib/symbols/bonds.rb

@@ -0,0 +1,28 @@
+# Sample bond contract definitions
+module IB
+  module Symbols
+    module Bonds
+      extend Symbols
+
+      def self.contracts
+        @contracts ||= {
+          :abbey  => IB::Contract.new(:symbol => "ABBEY",
+                                   :currency => "USD",
+                                   :sec_type => :bond,
+                                   :description => "Any ABBEY bond"),
+
+          :ms => IB::Contract.new(:symbol => "MS",
+                                   :currency => "USD",
+                                   :sec_type => :bond,
+                                   :description => "Any Morgan Stanley bond"),
+
+          :wag => IB::Contract.new(:symbol => "WAG",
+                                   :currency => "USD",
+                                   :sec_type => :bond,
+                                   :description => "Any Wallgreens bond"),
+        }
+      end
+
+    end
+  end
+end

data/plugins/ib/symbols/cfd.rb

@@ -0,0 +1,19 @@
+# Frequently used stock contracts definitions
+# TODO: auto-request :ContractDetails from IB if unknown symbol is requested?
+module IB
+  module Symbols
+    module CFD
+      extend Symbols
+
+      def self.contracts
+  @contracts.presence || super.merge(
+          :dax => IB::Contract.new(:symbol => "IBDE30", sec_type: :cfd,
+                                    :currency => "EUR",
+                                    :description => "DAX  CFD."),
+
+ )
+      end
+
+    end
+  end
+end

data/plugins/ib/symbols/combo.rb

@@ -0,0 +1,46 @@
+# Frequently used stock contracts definitions
+# TODO: auto-request :ContractDetails from IB if unknown symbol is requested?
+module IB
+  module Symbols
+    module  Combo
+      extend Symbols
+
+      def self.contracts
+        base = 4800
+        exp = IB::Option.next_expiry
+        @contracts ||= { #super.merge(
+          stoxx_straddle: IB::Straddle.build( from: IB::Symbols::Index.stoxx, strike: base,
+                                             expiry: exp, trading_class: 'OESX' ) ,
+          stoxx_calendar: IB::Calendar.build( from: IB::Symbols::Index.stoxx, strike: base, back: '2m' ,
+                                             front: exp, trading_class: 'OESX' ),
+         stoxx_butterfly: IB::Butterfly.fabricate( IB::Symbols::Options.stoxx.merge( strike: base - 200,
+                                                                    expiry: exp),
+                                                                    front: base - 400, back: base),
+          stoxx_vertical: IB::Vertical.build( from: IB::Symbols::Index.stoxx, 
+                                              sell: base - 200, buy: base + 200, 
+                                             right: :put,
+                                            expiry: exp, 
+                                     trading_class: 'OESX'),
+             zn_calendar: IB::Calendar.fabricate( IB::Symbols::Futures.zn.next_expiry, '3m') ,
+
+             dbk_straddle: Bag.new( symbol: 'DBK', currency: 'EUR', exchange: 'EUREX', combo_legs:
+                                [  ComboLeg.new( con_id: 270581032 , action: :buy, exchange: 'DTB', ratio: 1),   #DBK Dez20 2018 C
+                                   ComboLeg.new( con_id: 270580382,  action: :buy, exchange: 'DTB', ratio: 1 ) ], #DBK Dez 20 2018 P
+                                description: 'Option Straddle: Deutsche Bank(20)[Dez 2018]'),
+                   ib_mcd: Bag.new( symbol: 'IBKR,MCD', currency: 'USD', exchange: 'SMART',
+                                combo_legs: [  ComboLeg.new( con_id: 43645865, action: :buy, ratio: 1), # IKBR STK
+                                               ComboLeg.new( con_id: 9408,     action: :sell,ratio: 1 ) ], # MCD STK
+                               description: 'Stock Spread: Buy Interactive Brokers, sell Mc Donalds'),
+
+             vix_calendar:  Bag.new( symbol: 'VIX', currency: 'USD', exchange: 'CFE',
+                                 combo_legs: [  ComboLeg.new( con_id: 256038899, action: :buy, exchange: 'CFE', ratio: 1), #  VIX FUT 201708
+                                                ComboLeg.new( con_id: 260564703,  action: :sell, exchange: 'CFE', ratio: 1 ) ], # VIX FUT 201709
+                                description: 'VixFuture  Calendar-Spread August - September 2017'
+                                   )
+        }
+      # )
+      end
+
+    end
+  end
+end

data/plugins/ib/symbols/commodity.rb

@@ -0,0 +1,17 @@
+# Frequently used stock contracts definitions
+# TODO: auto-request :ContractDetails from IB if unknown symbol is requested?
+module IB
+  module Symbols
+    module Commodity
+      extend Symbols
+
+      def self.contracts
+    @contracts.presence || super.merge(
+          :xau => IB::Contract.new( symbol: 'XAUUSD', sec_type: :commodity, currency: 'USD',
+                                    :description => "London Gold ")
+     )
+      end
+
+    end
+  end
+end

data/plugins/ib/symbols/forex.rb

@@ -0,0 +1,41 @@
+module IB
+  module Symbols
+    module Forex
+      extend Symbols
+
+      def self.contracts
+        @contracts ||= define_contracts
+      end
+
+      private
+
+      # IDEALPRO is for orders over 20,000 and routes to the interbank quote stream.
+      # IDEAL is for smaller orders, and has wider spreads/slower execution... generally
+      # used for smaller currency conversions. IB::Symbols::Forex contracts are pre-defined
+      # on IDEALPRO, if you need something else please define forex contracts manually.
+      def self.define_contracts
+        @contracts = {}
+
+        # use combinations of these currencies for pre-defined forex contracts
+        currencies = [ "aud", "cad", "chf", "eur", "gbp", "hkd", "jpy", "nzd", "usd" ]
+
+        # create pairs list from currency list
+        pairs = currencies.product(currencies).
+          map { |pair| pair.join.upcase unless pair.first == pair.last }.compact
+
+        # now define each contract
+        pairs.each do |pair|
+          @contracts[pair.downcase.to_sym] = IB::Forex.new(
+            :symbol => pair[0..2],
+            :exchange => "IDEALPRO",
+            :currency => pair[3..5],
+            :local_symbol => pair[0..2]+'.'+pair[3..5],
+            :description => pair
+          )
+        end
+        
+        @contracts
+      end
+    end
+  end
+end

data/plugins/ib/symbols/futures.rb

@@ -0,0 +1,127 @@
+# The Futures module tries to guess the front month future using a crude algorithm that
+# does not take into account expiry/rollover day. This will be valid most of the time,
+# but near/after expiry day the next quarter's contract takes over as the volume leader.
+
+module IB
+  module Symbols
+    module Futures
+      extend Symbols
+
+
+      def self.contracts
+  @contracts.presence ||( super.merge  :ym => IB::Future.new(:symbol => "YM",
+                                  :expiry => IB::Future.next_expiry,
+                                  :exchange => "CBOT",
+                                  :currency => "USD",
+                                  :description => "Mini-DJIA future"),
+         :nq => IB::Future.new(:symbol => "NQ",
+                                  :expiry => IB::Future.next_expiry,
+                                  :exchange => "CME",
+                                  :currency => "USD",
+                                  :multiplier => 20,
+                                  :description => "Mini Nasdaq 100 future"),
+         :micro_nq => IB::Future.new(:symbol => "MNQ",
+                                  :expiry => IB::Future.next_expiry,
+                                  :exchange => "CME",
+                                  :currency => "USD",
+                                  :multiplier => 2,
+                                  :description => "Micro Nasdaq 100 future"),
+         :es => IB::Future.new(:symbol => "ES",
+                                  :expiry => IB::Future.next_expiry,
+                                  :exchange => "CME",
+                                  :currency => "USD",
+                                  :multiplier => 50,
+                                  :description => "Mini S&P 500 future"),
+         :micro_es => IB::Future.new(:symbol => "MES",
+                                  :expiry => IB::Future.next_expiry,
+                                  :exchange => "CME",
+                                  :currency => "USD",
+                                  :multiplier => 5,
+                                  :description => "Micro S&P 500 future"),
+         :russell => IB::Future.new(:symbol => "RTY",
+                                  :expiry => IB::Future.next_expiry,
+                                  :exchange => "CME",
+                                  :currency => "USD",
+                                  :multiplier => 5,
+                                  :description => "Mini Russell 2000 future"),
+         :micro_russell => IB::Future.new(:symbol => "M2K",
+                                  :expiry => IB::Future.next_expiry,
+                                  :exchange => "CME",
+                                  :currency => "USD",
+                                  :multiplier => 5,
+                                  :description => "Micro Russell 2000 future"),
+        :zn => IB::Future.new( symbol: 'ZN',
+                              expiry: IB::Future.next_expiry,
+                              currency: 'USD',
+                              multiplier: 1000,
+                              exchange: 'CBOT',
+                              description: 'US Treasury Note -- 10 Years'),
+        :zb => IB::Future.new( symbol: 'ZB',
+                              expiry: IB::Future.next_expiry,
+                              currency: 'USD',
+                              multiplier: 1000,
+                              exchange: 'CBOT',
+                              description: 'US Treasury Note -- 30 Years'),
+        :micro_dax => IB::Future.new( symbol: 'DAX', exchange: 'EUREX',
+                                  expiry:  IB::Future.next_expiry,
+                                  currency: 'EUR',
+                                  multiplier: 1,
+                                  description: 'Mini DAX-Future'),
+        :mini_dax => IB::Future.new( symbol: 'DAX', exchange: 'EUREX',
+                                  expiry:  IB::Future.next_expiry,
+                                  currency: 'EUR',
+                                  multiplier: 5,
+                                  description: 'Mini DAX-Future'),
+        :dax => IB::Future.new( symbol: 'DAX', exchange: 'EUREX',
+                                  expiry:  IB::Future.next_expiry,
+                                  currency: 'EUR',
+                                  multiplier: 25,
+                                  description: 'DAX-Future'),
+        :stoxx=> IB::Future.new( symbol: 'ESTX50', exchange: 'EUREX',
+                                  expiry:  IB::Future.next_expiry,
+                                  currency: 'EUR',
+                                  multiplier: 10,
+                                  description: 'EuroStoxx 50 -Future'),
+        :mini_stoxx=> IB::Future.new( symbol: 'ESTX50', exchange: 'EUREX',
+                                  expiry:  IB::Future.next_expiry,
+                                  currency: 'EUR',
+                                  multiplier: 1,
+                                  description: 'Mini/Micro EuroStoxx 50 -Future'),
+        :micro_stoxx=> IB::Future.new( symbol: 'ESTX50', exchange: 'EUREX',
+                                  expiry:  IB::Future.next_expiry,
+                                  currency: 'EUR',
+                                  multiplier: 1,
+                                  description: 'Miico EuroStoxx 50 -Future'),
+        :gbp => IB::Future.new(:symbol => "GBP",
+                                 :expiry => IB::Future.next_expiry,
+                                 :exchange => "CME",
+                                 :currency => "USD",
+                                 :multiplier => 62500,
+                                 :description => "British Pounds future"),
+         :eur => IB::Future.new(:symbol => "EUR",
+                                  :expiry => IB::Future.next_expiry,
+                                  :exchange => "CME",
+                                  :currency => "USD",
+                                  :multiplier => 12500,
+                                  :description => "Euro FX future"),
+         :jpy => IB::Future.new(:symbol => "JPY",
+                                  :expiry => IB::Future.next_expiry,
+                                  :exchange => "CME",
+                                  :currency => "USD",
+                                  :multiplier => 12500000,
+                                  :description => "Japanese Yen future"),
+         :hsi => IB::Future.new(:symbol => "HSI",
+                                  :expiry => IB::Future.next_expiry,
+                                  :exchange => "HKFE",
+                                  :currency => "HKD",
+                                  :multiplier => 50,
+                                  :description => "Hang Seng Index future"),
+         :vix => IB::Future.new(:symbol => "VIX",
+                                  :expiry => IB::Future.next_expiry,
+                                  :exchange => "CFE",
+                                  :currency => "USD",
+                                  :description => "CBOE Volatility Index future"))
+      end
+    end
+  end
+end