ib-extensions 1.1 → 1.3

data/lib/ib/option-chain.rb

@@ -1,25 +1,27 @@
 require 'ib/verify'
 require 'ib/market-price'
 module IB
-# define a custom ErrorClass which can be fired if a verification fails
-class VerifyError < StandardError
-end
 
 class Contract 
 
 
 
-  # returns the Option Chain of the contract (if available)
+  # returns the Option Chain  (monthly options, expiry: third friday) 
+  # of the contract (if available)
+  #
   #
   ## parameters
-  ### right:: :call, :put, :straddle
-  ### ref_price::  :request or a numeric value
+  ### right:: :call, :put, :straddle                ( default: :put )
+  ### ref_price::  :request or a numeric value      ( default:  :request )
   ### sort:: :strike, :expiry
   ### exchange:: List of Exchanges to be queried (Blank for all available Exchanges)
-  def option_chain ref_price: :request, right: :put, sort: :strike, exchange: ''
+  ### trading_class                                 ( optional )
+  def option_chain ref_price: :request, right: :put, sort: :strike, exchange: '', trading_class: nil
 
     ib = Connection.current
-    finalize =  Queue.new
+
+    # binary interthread communication
+    finalize = Queue.new
 
     ## Enable Cashing of Definition-Matrix
     @option_chain_definition ||= []
@@ -58,9 +60,8 @@ class Contract
         sec_type: c[:sec_type]
 
       finalize.pop #  wait until data appeared 
-      #i=0; loop { sleep 0.1; break if i> 1000 || finalize; i+=1 } 
 
-      ib.unsubscribe sub_sdop , sub_ocd
+      ib.unsubscribe sub_sdop, sub_ocd
     else
       Connection.logger.info { "#{to_human} : using cached data" }
     end
@@ -69,18 +70,18 @@ class Contract
     # select values and assign to options
     #
     unless @option_chain_definition.blank? 
-      requested_strikes =  if block_given?  
+      requested_strikes = if block_given?
                              ref_price = market_price if ref_price == :request
                              if ref_price.nil?
-                               ref_price =	 @option_chain_definition[:strikes].min  +
-                                 ( @option_chain_definition[:strikes].max -  
-                                  @option_chain_definition[:strikes].min ) / 2 
+                               ref_price = @option_chain_definition[:strikes].min +
+                                 ( @option_chain_definition[:strikes].max -
+                                  @option_chain_definition[:strikes].min ) / 2
                                Connection.logger.warn { "#{to_human} :: market price not set – using midpoint of available strikes instead: #{ref_price.to_f}" }
                              end
                              atm_strike = @option_chain_definition[:strikes].min_by { |x| (x - ref_price).abs }
                              the_grouped_strikes = @option_chain_definition[:strikes].group_by{|e| e <=> atm_strike}	
                              begin
-                               the_strikes =		yield the_grouped_strikes
+                               the_strikes = yield the_grouped_strikes
                                the_strikes.unshift atm_strike unless the_strikes.first == atm_strike	  # the first item is the atm-strike
                                the_strikes
                              rescue
@@ -92,34 +93,34 @@ class Contract
                            end
 
       # third Friday of a month
-      monthly_expirations =  @option_chain_definition[:expirations].find_all{|y| (15..21).include? y.day }
+      monthly_expirations = @option_chain_definition[:expirations].find_all {|y| (15..21).include? y.day }
       #				puts @option_chain_definition.inspect
-      option_prototype = -> ( ltd, strike ) do 
-        IB::Option.new symbol: symbol, 
-          exchange: @option_chain_definition[:exchange], 
-          trading_class: @option_chain_definition[:trading_class], 
-          multiplier: @option_chain_definition[:multiplier], 
-          currency: currency,  
-          last_trading_day: ltd, 
-          strike: strike, 
-          right: right  
+      option_prototype = -> ( ltd, strike ) do
+        IB::Option.new( symbol: symbol,
+          exchange: @option_chain_definition[:exchange],
+          trading_class: @option_chain_definition[:trading_class],
+          multiplier: @option_chain_definition[:multiplier],
+          currency: currency,
+          last_trading_day: ltd,
+          strike: strike,
+          right: right).verify &.first
       end
       options_by_expiry = -> ( schema ) do
         # Array: [ yymm -> Options] prepares for the correct conversion to a Hash
         Hash[  monthly_expirations.map do | l_t_d |
-          [  l_t_d.strftime('%y%m').to_i , schema.map{ | strike | option_prototype[ l_t_d, strike ]}.compact ]
+          [  l_t_d.strftime('%y%m').to_i , schema.map { | strike | option_prototype[ l_t_d, strike ]}.compact ]
         end  ]                         # by Hash[ ]
       end
       options_by_strike = -> ( schema ) do
         Hash[ schema.map do | strike |
-          [  strike ,   monthly_expirations.map{ | l_t_d | option_prototype[ l_t_d, strike ]}.compact ]
+          [  strike ,   monthly_expirations.map { | l_t_d | option_prototype[ l_t_d, strike ]}.compact ]
         end  ]                         # by Hash[ ]
       end
 
       if sort == :strike
-        options_by_strike[ requested_strikes ] 
+        options_by_strike[ requested_strikes ]
       else 
-        options_by_expiry[ requested_strikes ] 
+        options_by_expiry[ requested_strikes ]
       end
     else
       Connection.logger.error "#{to_human} ::No Options available"
@@ -128,8 +129,8 @@ class Contract
   end  # def
 
   # return a set of AtTheMoneyOptions
-  def atm_options ref_price: :request, right: :put
-    option_chain(  right: right, ref_price: ref_price, sort: :expiry) do | chain |
+  def atm_options ref_price: :request, right: :put, **params
+    option_chain(  right: right, ref_price: ref_price, sort: :expiry, **params) do | chain |
       chain[0]
     end
 
@@ -137,8 +138,8 @@ class Contract
   end
 
   # return   InTheMoneyOptions
-  def itm_options count:  5, right: :put, ref_price: :request, sort: :strike
-    option_chain(  right: right,  ref_price: ref_price, sort: sort ) do | chain |
+  def itm_options count:  5, right: :put, ref_price: :request, sort: :strike, exchange: ''
+    option_chain(  right: right,  ref_price: ref_price, sort: sort, exchange: exchange ) do | chain |
       if right == :put
         above_market_price_strikes = chain[1][0..count-1]
       else
@@ -148,8 +149,8 @@ class Contract
   end		# def
 
   # return OutOfTheMoneyOptions
-  def otm_options count:  5,  right: :put, ref_price: :request, sort: :strike
-    option_chain( right: right, ref_price: ref_price, sort: sort ) do | chain |
+  def otm_options count:  5,  right: :put, ref_price: :request, sort: :strike, exchange: ''
+    option_chain( right: right, ref_price: ref_price, sort: sort, exchange: exchange ) do | chain |
       if right == :put
         #			puts "Chain: #{chain}"
         below_market_price_strikes = chain[-1][-count..-1].reverse
@@ -160,34 +161,6 @@ class Contract
   end
 
 
-  def associate_ticdata
-
-    tws=  IB::Connection.current 		 # get the initialized ib-ruby instance
-    the_id =  nil
-    finalize= false
-    #  switch to delayed data
-    tws.send_message :RequestMarketDataType, :market_data_type => :delayed
-
-    s_id = tws.subscribe(:TickSnapshotEnd) { |msg|	finalize = true	if msg.ticker_id == the_id }
-
-    sub_id = tws.subscribe(:TickPrice, :TickSize,  :TickGeneric, :TickOption) do |msg|
-      self.bars << msg.the_data if msg.ticker_id == the_id 
-    end
-
-    # initialize »the_id« that is used to identify the received tick messages
-    # by firing the market data request
-    the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true 
-
-    #keep the method-call running until the request finished
-    #and cancel subscriptions to the message handler.
-    Thread.new do 
-      i=0; loop{ i+=1; sleep 0.1; break if finalize || i > 1000 }
-      tws.unsubscribe sub_id 
-      tws.unsubscribe s_id
-      #puts "#{symbol} data gathered" 
-    end  # method returns the (running) thread
-
-  end # def 
 end # class
 
 

data/lib/ib/option-greeks.rb

@@ -1,44 +1,45 @@
 module IB
 
 
-	
  class Option
-# Ask for the Greeks and implied Vola 
-# 
+# Ask for the Greeks and implied Vola
+#
 # The result can be customized by a provided block.
-# 
-# 	IB::Symbols::Options.aapl.greeks{ |x| x }
-# 	-> {"bid"=>0.10142e3, "ask"=>0.10144e3, "last"=>0.10142e3, "close"=>0.10172e3}
-#  
+#
+#	IB::Symbols::Options.aapl.greeks{ |x| x }
+#	-> {"bid"=>0.10142e3, "ask"=>0.10144e3, "last"=>0.10142e3, "close"=>0.10172e3}
+#
 #   Possible values for Parameter :what --> :all :model, :bid, :ask, :bidask, :last
-# 
+#
 	 def request_greeks delayed:  true, what: :model, thread: false
 
-		 tws=  Connection.current 		 # get the initialized ib-ruby instance
+		 tws = Connection.current 		 # get the initialized ib-ruby instance
 		 # define requested tick-attributes
-		 request_data_type = IB::MARKET_DATA_TYPES.rassoc( delayed ? :frozen_delayed :  :frozen ).first
+		 request_data_type = IB::MARKET_DATA_TYPES.rassoc( delayed ? :frozen_delayed : :frozen ).first
 		 # possible types = 	[ [ :delayed_model_option , :model_option ] , [:delayed_last_option , :last_option ],
-		 # [ :delayed_bid_option , :bid_option ], [ :delayed_ask_option , :ask_option ]	]											  	        
+		 # [ :delayed_bid_option , :bid_option ], [ :delayed_ask_option , :ask_option ]]
 		 tws.send_message :RequestMarketDataType, :market_data_type =>  request_data_type
 		 tickdata = []
 
 		 self.greek = OptionDetail.new if greek.nil?
-		 greek.updated_at = Time.now
+     greek.updated_at = Time.now
+     greek.option = self
+     queue =  Queue.new
 
 		 #keep the method-call running until the request finished
 		 #and cancel subscriptions to the message handler
 		 # method returns the (running) thread
 		 th = Thread.new do
 			 the_id  =  nil
-			 finalize= false
 			 # subscribe to TickPrices
-			 s_id = tws.subscribe(:TickSnapshotEnd) { |msg|	finalize = true	if msg.ticker_id == the_id }
-			 e_id = tws.subscribe(:Alert){|x|  finalize = true if [200,353].include?( x.code) && x.error_id == the_id } 
+       s_id = tws.subscribe(:TickSnapshotEnd) { |msg|	queue.push(true)	if msg.ticker_id == the_id  }
+       e_id = tws.subscribe(:Alert){|x| queue.push(false)  if [200,353].include?( x.code) && x.error_id == the_id }
+       t_id = tws.subscribe( :TickSnapshotEnd, :TickPrice, :TickString, :TickSize, :TickGeneric, :MarketDataType, :TickRequestParameters  ) {|msg| msg }
 			 # TWS Error 200: No security definition has been found for the request
 			 # TWS Error 354: Requested market data is not subscribed.
 
 			 sub_id = tws.subscribe(:TickOption ) do |msg| #, :TickSize,  :TickGeneric  do |msg|
-				 if  msg.ticker_id == the_id && tickdata.is_a?(Array) # do nothing if tickdata have already gathered
+				 if  msg.ticker_id == the_id # && tickdata.is_a?(Array) # do nothing if tickdata have already gathered
 					 case msg.type
 					 when /ask/
 						 greek.ask_price = msg.option_price unless msg.option_price.nil?
@@ -55,34 +56,36 @@ module IB
 						 (bf + msg.greeks.keys).each{ |a| greek.send( a.to_s+"=", msg.send( a)) }
 						 tickdata << msg  if [ :all, :model ].include?( what	)
 					 end
-					 tickdata =  tickdata &.first unless [:bidask, :all].include? what
-					 finalize = true if tickdata.is_a?(IB::Messages::Incoming::TickOption) || (tickdata.size == 2 && what== :bidask) || (tickdata.size == 4 && what == :all)
+           # fast entry abortion ---> daiabled for now
+         #  queue.push(true) if tickdata.is_a?(IB::Messages::Incoming::TickOption) || (tickdata.size == 2 && what== :bidask) || (tickdata.size == 4 && what == :all)
 				 end
 			 end  # if sub_id
 
 			 # initialize »the_id« that is used to identify the received tick messages
 			 # by firing the market data request
-			 the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true 
+       iji = 0
+       loop do
+         the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true
 
-			 begin
-				 # todo implement config-feature to set timeout in configuration   (DRY-Feature)
-				 Timeout::timeout(5) do   # max 5 sec.
-					 loop{ break if finalize ; sleep 0.05 } 
-					 # reduce :close_price delayed_close  to close a.s.o 
-					 self.misc =  tickdata if thread  # store internally if in thread modus
-				 end
-			 rescue Timeout::Error
-				 Connection.logger.info{ "#{to_human} --> No Marketdata received " }
-			 end
-			 tws.unsubscribe sub_id, s_id, e_id
+         result = queue.pop
+         # reduce :close_price delayed_close  to close a.s.o
+         if result == false
+           Connection.logger.info{ "#{to_human} --> No Marketdata received " }
+         else
+           self.misc =  tickdata if thread  # store internally if in thread modus
+         end
+         break if  !tickdata.empty?  ||  iji > 10
+         iji =  iji + 1
+         Connection.logger.info{ "OptionGreeks::#{to_human} --> delayed processing. Trying again (#{iji}) " }
+       end
+			 tws.unsubscribe sub_id, s_id, e_id, t_id
 		 end  # thread
 		 if thread
 			 th		# return thread
 		 else
 			 th.join
-			 tickdata	# return 
+       greek
 		 end
-	 end #
-
+   end
  end
 end

data/lib/ib/order_prototypes/all-in-one.rb

@@ -0,0 +1,46 @@
+module IB
+
+#Combo-Orders are used for NonGuaranteed Orders only.
+#»Normal« Option-Spreads are transmited by ordinary Limit-Orders
+    module Combo
+      ### Basic Order Prototype: Combo with two limits
+      extend OrderPrototype
+      class << self
+      def defaults
+	## todo implement serialisation of  key/tag Hash to camelCased-keyValue-List 
+#      super.merge order_type: :limit , combo_params: { non_guaranteed: true} 
+	#      for the time being, we use the array representation
+      super.merge order_type: :limit , combo_params: [ ['NonGuaranteed', true] ]
+      end
+
+
+      def requirements
+				Limit.requirements
+      end
+
+      def aliases
+				Limit.aliases
+      end
+
+
+      def summary
+	<<-HERE
+	Create combination orders. It is constructed through  options, stock and futures legs 
+	(stock legs can be included if the order is routed through SmartRouting). 
+	
+	Although a combination/spread order is constructed of separate legs, it is executed 
+	as a single transaction if it is routed directly to an exchange. For combination orders 
+	that are SmartRouted, each leg may be executed separately to ensure best execution. 
+
+	The »NonGuaranteed«-Flag is set to "false". A Pair of two securites should always be
+	routed »Guaranteed«, otherwise separate orders are prefered.
+
+	If a Bag-Order with »NonGuarateed :true« should be submitted, the Order-Type would be 
+	REL+MKT, LMT+MKT, or REL+LMT 
+	--------
+	Products: Options, Stocks, Futures
+	HERE
+      end # def
+      end # class
+    end	# module combo
+end  # module ib

data/lib/ib/plot-poec.rb

@@ -0,0 +1,60 @@
+require 'distribution'
+require 'gnuplot'
+
+## source:  ChatGpt
+# Set the variables
+s = 100 # current stock price
+k = 110 # strike price
+t = 0.5 # time to expiry (in years)
+r = 0.02 # risk-free interest rate
+sigma = 0.2 # implied volatility
+p = 0.7 # probability
+
+# Calculate d1 and d2
+d1 = (Math.log(s/k) + (r + 0.5*sigma**2)*t) / (sigma * Math.sqrt(t))
+d2 = d1 - sigma * Math.sqrt(t)
+
+# Calculate the Z-score for the desired probability
+z_score = Distribution::Normal.inv_cdf(p + (1-p)/2)
+
+# Calculate the upper and lower bounds of the 70% probability range
+upper_bound = s * Math.exp((r - 0.5*sigma**2)*t + sigma*Math.sqrt(t)*z_score)
+lower_bound = s * Math.exp((r - 0.5*sigma**2)*t + sigma*Math.sqrt(t)*(-z_score))
+
+# Create the plot
+Gnuplot.open do |gp|
+  Gnuplot::Plot.new(gp) do |plot|
+    plot.title 'Probability Density Function with 70% probability range'
+    plot.xlabel 'Stock Price'
+    plot.ylabel 'Probability Density'
+
+    # Set the x-axis range
+    plot.xrange "[#{s*0.6}:#{s*1.4}]"
+
+    # Plot the probability density function
+    x = (s*0.6..s*1.4).step(0.1).to_a
+    y = x.map { |xi| Distribution::Normal.pdf((Math.log(xi/s) + (r - 0.5*sigma**2)*t) / (sigma * Math.sqrt(t))) / (xi*sigma*Math.sqrt(t))  }
+    plot.data << Gnuplot::DataSet.new([x, y]) do |ds|
+      ds.with = 'lines'
+      ds.linewidth = 2
+      ds.linecolor = 'blue'
+    end
+
+    # Plot the upper and lower bounds of the 70% probability range
+    plot.data << Gnuplot::DataSet.new([lower_bound, 0]) do |ds|
+      ds.with = 'lines'
+      ds.linewidth = 2
+      ds.linecolor = 'red'
+    end
+    plot.data << Gnuplot::DataSet.new([upper_bound, 0]) do |ds|
+      ds.with = 'lines'
+      ds.linewidth = 2
+      ds.linecolor = 'red'
+    end
+    plot.data << Gnuplot::DataSet.new([[lower_bound, upper_bound], [0, 0]]) do |ds|
+      ds.with = 'filledcurve x1=1 x2=2'
+      ds.fillcolor = 'red'
+      ds.fillstyle = 'transparent solid 0.2'
+    end
+  end
+end

data/lib/ib/probability_of_expiring.rb

@@ -0,0 +1,109 @@
+module IB
+  module ProbabilityOfExpiring
+
+    # Use  by calling
+    #   a = Stock.new symbol: 'A'
+    #
+    require 'prime'
+    require 'distribution'
+
+
+
+    def probability_of_assignment  **args
+      ( probability_of_expiring(**args) - 1 ).abs
+    end
+    def probability_of_expiring  **args
+      @probability_of_expiring = calculate_probability_of_expiring(**args) if @probability_of_expiring.nil? ||  ! args.empty?
+      @probability_of_expiring
+    end
+
+    private
+=begin
+Here are the steps to calculate the probability of expiry cone for a stock in
+the next six months using the Black-Scholes model:
+
+*  Determine the current stock price and the strike price for the option you
+   are interested in. Let's say the current stock price is $100 and the strike
+   price is $110.  *  Determine the time to expiry. In this case, we are
+   interested in the next six months, so the time to expiry is 0.5 years.  *
+   Determine the implied volatility of the stock. Implied volatility is a measure
+   of the expected volatility of the stock over the life of the option, and can be
+   estimated from the option prices in the market.
+
+* Use the Black-Scholes formula to calculate the probability of the stock
+  expiring within the range of prices that make up the expiry cone. The formula
+  is:
+
+                    P = N(d2)
+
+  Where P is the probability of the stock expiring within the expiry cone, and
+  N is the cumulative distribution function of the standard normal
+  distribution. d2 is calculated as:
+
+                    d2 = (ln(S/K) + (r - 0.5 * σ^2) * T) / (σ * sqrt(T))
+
+  Where S is the current stock price, K is the strike price, r is the risk-free
+  interest rate, σ is the implied volatility, and T is the time to expiry.
+
+  Look up the value of N(d2) in a standard normal distribution table, or use a
+  calculator or spreadsheet program that can calculate cumulative distribution
+  functions.
+
+  The result is the probability of the stock expiring within the expiry cone.
+  For example, if N(d2) is 0.35, then the probability of the stock expiring
+                 within the expiry cone is 35%.
+
+(ChatGPT)
+=end
+    def calculate_probability_of_expiring price: nil,
+                                          interest: 0.03,
+                                          iv: nil,
+                                          strike: nil,
+                                          expiry: nil,
+                                          ref_date: Date.today
+
+      if iv.nil?  && self.respond_to?( :greek )
+        IB::Connection.current.logger.info "Probability_of_expiring: using current IV and Underlying-Price for calculation"
+          request_greeks if greek.nil?
+          iv = greek.implied_volatility
+          price = greek.under_price if price.nil?
+      end
+      error "ProbabilityOfExpiringCone needs iv as input" if iv.nil? || iv.zero?
+
+      if price.nil?
+        price =  if self.strike.to_i.zero?
+                   market_price
+                 else
+                   underlying.market_price
+                 end
+      end
+      error "ProbabilityOfExpiringCone needs price as input" if price.to_i.zero?
+
+
+      strike ||= self.strike
+      error "ProbabilityOfExpiringCone needs strike as input" if strike.to_i.zero?
+
+      if expiry.nil?
+        if last_trading_day == ''
+          error "ProbabilityOfExpiringCone needs expiry as input"
+        else
+          expiry = last_trading_day
+        end
+      end
+      time_to_expiry = ( Date.parse( expiry.to_s ) - ref_date ).to_i
+
+      # # Calculate d1 and d2
+      d1 = (Math.log(price/strike.to_f) + (interest + 0.5*iv**2)*time_to_expiry) / (iv * Math.sqrt(time_to_expiry))
+      d2 = d1 - iv * Math.sqrt(time_to_expiry)
+      #
+      # # Calculate the probability of expiry cone
+      Distribution::Normal.cdf(d2)
+
+    end
+  end
+
+  class Contract
+    include ProbabilityOfExpiring
+  end
+
+end

data/lib/ib/spread-prototypes.rb

@@ -24,6 +24,7 @@ module IB
 
 		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 )

data/lib/ib/spread_prototypes/butterfly.rb

@@ -25,8 +25,7 @@ module IB
 					error "fabrication is based on a master option. Please specify as first argument" unless master.is_a?(IB::Option)
 					strike = master.strike
 					master.right = :put unless master.right == :call
-					l=[] ; master.verify{|x| x.contract_detail= nil; l << x }
-#					puts "master:  #{master.attributes.inspect}"
+					l= master.verify
 					if l.empty?
 						error "Invalid Parameters. No Contract found #{master.to_human}" 
 					elsif l.size > 1
@@ -43,7 +42,7 @@ module IB
 						strikes = [front, master.strike, back]
 						strikes.zip([1, -2, 1]).each do |strike, ratio|
 							action = ratio >0 ?  :buy : :sell
-							leg =  IB::Option.new( master.attributes.merge( strike: strike )).verify!.essential
+              leg =  IB::Option.new( master.attributes.merge( strike: strike )).verify.first.essential
 							the_spread.add_leg  leg,  action: action,  ratio: ratio.abs 
 						end
 						the_spread.description =  the_description( the_spread )
@@ -53,7 +52,6 @@ module IB
 
 				def  build from: , front:, back:,  **options
 					underlying_attributes =  { expiry: IB::Symbols::Futures.next_expiry, right: :put }.merge( from.attributes.slice( :symbol, :currency, :exchange, :strike )).merge( options )
-					puts underlying_attributes.inspect
 					fabricate  IB::Option.new( underlying_attributes), front: front, back: back
 				end
 

data/lib/ib/spread_prototypes/calendar.rb

@@ -16,16 +16,13 @@ module IB
 			def fabricate master, the_other_expiry
 
 				error "Argument must be a IB::Future or IB::Option" unless  [:option, :future_option, :future ].include? master.sec_type
-
-				initialize_spread( master ) do | the_spread |
-					the_spread.add_leg master, action: :buy
-					
-					the_other_expiry =  the_other_expiry.values.first if the_other_expiry.is_a?(Hash)
-					back = the_spread.transform_distance master.expiry, the_other_expiry
-					the_spread.add_leg master.merge(expiry: back ), action: :sell
-					error "Initialisation of Legs failed" if the_spread.legs.size != 2
-					the_spread.description =  the_description( the_spread )
-				end
+        m = master.verify.first
+        the_other_expiry =  the_other_expiry.values.first if the_other_expiry.is_a?(Hash)
+        back = IB::Spread.transform_distance m.expiry, the_other_expiry
+        calendar =  m.roll expiry: back
+        error "Initialisation of Legs failed" if calendar.legs.size != 2
+				calendar.description =  the_description( calendar )
+        calendar  #  return fabricated spread
 			end
 
 
@@ -46,25 +43,30 @@ module IB
 											 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 =  nil; from.verify{|c| details = c.contract_detail }
+                       details = from.verify.first.contract_detail 
 											 IB::Contract.new( con_id: details.under_con_id, 
-																				currency: from.currency)
-																			 .verify!
-																			 .essential
+																				currency: from.currency).verify.first.essential
 										 else
 											 from
 										 end
 				kind = { :front => fields.delete(:front), :back => fields.delete(:back) }
-				error "Specifiaction of :front and :back expiries nessesary, got: #{kind.inspect}" if kind.values.any?(nil)
+				error "Specifiaction of :front and :back expiries necessary, got: #{kind.inspect}" if kind.values.any?(nil)
 				initialize_spread( underlying ) do | the_spread |
-					leg_prototype  = IB::Option.new underlying.attributes
-															.slice( :currency, :symbol, :exchange)
-															.merge(defaults)
-															.merge( fields )
-					kind[:back] = the_spread.transform_distance kind[:front], kind[:back]
+          leg_prototype  = IB::Option.new underlying.attributes
+            .slice( :currency, :symbol, :exchange)
+            .merge(defaults)
+            .merge( fields )
+					kind[:back] = IB::Spread.transform_distance kind[:front], kind[:back]
 					leg_prototype.sec_type = 'FOP' if underlying.is_a?(IB::Future)
-					the_spread.add_leg IB::Contract.build( leg_prototype.attributes.merge(expiry: kind[:front] )), action: :buy
-					the_spread.add_leg IB::Contract.build( leg_prototype.attributes.merge(expiry: kind[:back])), action: :sell
+          leg1 =  leg_prototype.merge(expiry: kind[:front] ).verify.first
+          leg2 = leg_prototype.merge(expiry: kind[:back] ).verify.first
+          unless leg2.is_a? IB::Option
+            leg2_trading_class = ''
+            leg2 = leg_prototype.merge(expiry: kind[:back] ).verify.first
+
+          end
+          the_spread.add_leg leg1 , action: :buy
+          the_spread.add_leg leg2 , action: :sell
 					error "Initialisation of Legs failed" if the_spread.legs.size != 2
 					the_spread.description =  the_description( the_spread )
 				end
@@ -78,7 +80,7 @@ module IB
 
 			def the_description spread
 			x= [ spread.combo_legs.map(&:weight) , spread.legs.map( &:last_trading_day )].transpose
-			 "<Calendar #{spread.symbol} #{spread.legs.first.right}(#{spread.legs.first.strike})[#{x.map{|w,l_t_d| "#{w} :#{Date.parse(l_t_d).strftime("%b %Y")} "}.join( '|+|' )} >"
+		 "<Calendar #{spread.symbol} #{spread.legs.first.right}(#{spread.legs.first.strike})[#{x.map{|w,l_t_d| "#{w} :#{Date.parse(l_t_d).strftime("%b %Y")} "}.join( '|+|' )} >"
 			end
 		 end # class
     end	# module vertical

data/lib/ib/spread_prototypes/straddle.rb

@@ -43,11 +43,11 @@ module IB
 						leg_prototype  = IB::Option.new from.attributes
 						.slice( :currency, :symbol, :exchange)
 						.merge(defaults)
-						.merge( fields )
+              .merge( fields )
 
 						leg_prototype.sec_type = 'FOP' if from.is_a?(IB::Future)
-						the_spread.add_leg IB::Contract.build leg_prototype.attributes.merge( right: :put )
-						the_spread.add_leg IB::Contract.build leg_prototype.attributes.merge( right: :call )
+            the_spread.add_leg leg_prototype.merge( right: :put ).verify.first
+            the_spread.add_leg leg_prototype.merge( right: :call ).verify.first
 						error "Initialisation of Legs failed" if the_spread.legs.size != 2
 						the_spread.description =  the_description( the_spread )
 					end