ib-api 10.33.1

data/plugins/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.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.present? || last_trading_day.empty?
+          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/plugins/ib/process-orders.rb

@@ -0,0 +1,155 @@
+module IB
+=begin
+
+Plugin for a comfortable processing of orders
+
+Public API
+==========
+
+Extends IB::Connection
+
+* initialize_order_handling
+
+  subscribes to various tws-messages and keeps record of the order-state
+
+* request_open_orders
+
+  (aliased as UpdateOrders) erases account.orders and requests open-orders from the TWS
+  and populates Account#Orders
+
+=end
+  module ProcessOrders
+  protected
+  def initialize_order_handling
+
+    subscribe( :CommissionReport, :ExecutionData, :OrderStatus, :OpenOrder, :OpenOrderEnd, :NextValidId ) do |msg|
+      case msg
+
+      when IB::Messages::Incoming::CommissionReport
+        # Commission-Reports are not assigned to a order -
+        logger.info "CommissionReport -------#{msg.exec_id} :...:C: #{msg.commission} :...:P/L: #{msg.realized_pnl}-"
+      when IB::Messages::Incoming::OrderStatus
+
+        # The order-state only links via local_id and perm_id to orders.
+        # There is no reference to a contract or an account
+
+        success = update_order_dependent_object( msg.order_state) do |o|
+          o.order_states.save_insert msg.order_state, :status
+        end
+
+        logger.warn {  "Order State not assigned-- #{msg.order_state.to_human} ----------" } if success.nil?
+
+      when IB::Messages::Incoming::OpenOrder
+        account_data(msg.order.account) do | this_account |
+          # first update the contracts
+          # make open order equal to IB::Spreads (include negativ con_id)
+          msg.contract[:con_id] = -msg.contract.combo_legs.map{|y| y.con_id}.sum  if msg.contract.is_a? IB::Bag
+          msg.contract.orders.save_insert msg.order, :local_id
+          this_account.contracts.save_insert msg.contract, :con_id, false
+          # now save the order-record
+          msg.order.contract = msg.contract
+          this_account.orders.save_insert msg.order, :local_id
+        end
+
+        #     update_ib_order msg  ## aus support
+      when IB::Messages::Incoming::OpenOrderEnd
+        #             exitcondition=true
+        logger.debug { "OpenOrderEnd" }
+
+      when IB::Messages::Incoming::ExecutionData
+        # Excution-Data are fired independly from order-states.
+        # The Objects are stored at the associated order
+        success = update_order_dependent_object( msg.execution) do |o|
+          o.executions << msg.execution
+          if msg.execution.cumulative_quantity.to_i == o.total_quantity.abs
+            logger.info{ "#{o.account} --> #{o.contract.symbol}: Execution completed" }
+            o.order_states << IB::OrderState.new( perm_id: o.perm_id,
+                                                 local_id: o.local_id,
+                                                   status: 'Filled' )
+            # update portfoliovalue
+            a = @accounts.detect{ | x | x.account == o.account } #  we are in a mutex controlled environment
+            pv = a.portfolio_values.detect{ | y | y.contract.con_id == o.contract.con_id}
+            change = o.action == :sell ? -o.total_quantity : o.total_quantity
+            if pv.present?
+              pv.update_attribute :position, pv.position + change
+            else
+              a.portfolio_values << IB::PortfolioValue.new( position: change, contract: o.contract )
+            end
+          else
+            logger.debug{ "#{o.account} --> #{o.contract.symbol}: Execution not completed (#{msg.execution.cumulative_quantity.to_i}/#{o.total_quantity.abs})" }
+          end  # branch
+        end # block
+
+        logger.warn { "Execution-Record not assigned-- #{msg.execution.to_human} ----------" } if success.nil?
+
+      end  # case msg.code
+    end # do
+  end # def subscribe
+
+  # Resets the order-array for each account.
+  # Requests all open (eg. pending)  orders from the tws
+  #
+  # Waits until the OpenOrderEnd-Message is received
+
+  public
+  def request_open_orders
+
+    q =  Queue.new
+    subscription = subscribe( :OpenOrderEnd ) { q.push(true) }  # signal success
+    account_data {| account | account.orders = [] }
+    send_message :RequestAllOpenOrders
+    ## the OpenOrderEnd-message usually appears after 0.1 sec.
+    ## we wait for 1 sec.
+    th =  Thread.new{   sleep 1 ; q.close  }
+
+    q.pop # wait for OpenOrderEnd or finishing of thread
+
+    unsubscribe subscription
+    if q.closed?
+      5.times do
+      logger.fatal { "Is the API in read-only modus?  No Open Order Message received! "}
+      sleep  0.2
+      end
+    else
+      Thread.kill(th)
+      q.close
+      account_data {| account | account.orders } # reset order array
+    end
+  end
+
+  alias update_orders request_open_orders
+
+  private
+=begin
+UpdateOrderDependingObject
+
+Generic method which enables operations on the order-Object,
+which is associated to OrderState-, Execution-, CommissionReport-
+events fired by the tws.
+The order is identified by local_id and perm_id
+
+Everything is carried out in a mutex-synchonized environment
+=end
+  def update_order_dependent_object order_dependent_object  # :nodoc:
+   account_data  do  | a |
+      order = if order_dependent_object.local_id.present?
+                a.locate_order local_id: order_dependent_object.local_id
+              else
+                a.locate_order perm_id: order_dependent_object.perm_id
+              end
+      yield order if order.present?
+    end
+  end
+
+
+end # module
+
+class Connection
+  include ProcessOrders
+end
+Connection.current.activate_plugin 'managed-accounts'
+Connection.current.initialize_managed_accounts!
+Connection.current.initialize_order_handling!
+
+end   ##  module IB
+

data/plugins/ib/roll.rb

@@ -0,0 +1,86 @@
+module IB
+  module RollFuture
+    # helper method to roll an existing future
+    #
+    # Argument is the expiry of the target-future or the distance
+    #
+    # > nq =  IB::Symbols::Futures.nq.verify.first
+    # > t= nq.roll to: '3m'
+    # > puts t.as_table
+# ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
+# │  Roll NQ future from Sep 24 to Dec 24 /  buy 1 <Future: NQ 20240920 USD> /  sell 1 <Future: NQ 20241220 USD  │
+# ├────────┬────────┬─────────────┬──────────┬──────────┬────────────┬───────────────┬───────┬────────┬──────────┤
+# │        │ symbol │ con_id      │ exchange │ expiry   │ multiplier │ trading-class │ right │ strike │ currency │
+# ╞════════╪════════╪═════════════╪══════════╪══════════╪════════════╪═══════════════╪═══════╪════════╪══════════╡
+# │ Spread │ NQ     │ -1201481183 │   CME    │          │     20     │               │       │        │   USD    │
+# │ Future │ NQ     │   637533450 │   CME    │ 20240920 │     20     │      NQ       │       │        │   USD    │
+# │ Future │ NQ     │   563947733 │   CME    │ 20241220 │     20     │      NQ       │       │        │   USD    │
+# └────────┴────────┴─────────────┴──────────┴──────────┴────────────┴───────────────┴───────┴────────┴──────────┘
+    # > t= nq.roll expiry: 202412
+    # > puts t.to_human
+    # <Roll NQ future from Sep 24 to Dec 24 /  buy 1 <Future: NQ 20240920 USD> /  sell 1 <Future: NQ 20241220 USD>
+
+
+    def roll **args
+      print_expiry = ->(f){ Date.parse(f.last_trading_day).strftime('%b %y') }
+      error "specify expiry to roll a future" if args.empty?
+      args[:to] = args[:expiry] if args[:expiry].present?  && args[:expiry].to_s =~ /[mwMW]$/
+      args[:expiry]= IB::Spread.transform_distance( expiry, args.delete(:to  )) if args[:to].present?
+
+      new_future =  merge( **args ).verify.first
+      error "Cannot roll future; target is no IB::Contract" unless new_future.is_a? IB::Future
+      target = IB::Spread.new exchange: exchange, symbol: symbol, currency: currency,
+      description: "<Roll #{symbol} future from #{print_expiry[self]} to #{print_expiry[new_future]}"
+      target.add_leg self, action:  :sell
+      target.add_leg new_future, action: :buy
+    end
+  end
+
+
+  module RollOption
+    # helper method to roll an existing short-poption
+    #
+    # Arguments are strike and expiry of the target-option.
+    #
+    # Example:  r= Symbols::Options.rut.merge(strike: 2000).next_expiry.roll( strike:  1900 )
+    #           r.to_human
+    #        => " rolling <Option: RUT 20240516 put 2000.0 SMART USD> to <Option: RUT 20240516 put 1900.0 SMART USD>"
+    #           r.combo_legs.to_human
+    #        => ["<ComboLeg: buy 1 con_id 684936898 at SMART>", "<ComboLeg: sell 1 con_id 684936524 at SMART>"]
+    #
+    #   rolls the Option to another strike and/or expiry
+    #
+    #   Same Expiry, roll down the strike
+    #   `r= Symbols::Options.rut.merge(strike: 2000).next_expiry.roll( strike:  1900 ) `
+    #
+    #   Same Expiry, roll to the next month
+    #   `r= Symbols::Options.rut.merge(strike: 2000).next_expiry.roll( expiry:  '+1m' ) `
+
+    def roll **args
+      error "specify strike and expiry to roll option" if args.empty?
+      args[:to] = args[:expiry] if args[:expiry].present?  && args[:expiry].to_s =~ /[mwMW]$/
+      args[:expiry]= IB::Spread.transform_distance( expiry, args.delete(:to  )) if args[:to].present?
+
+      new_option =  merge( ** args ).then{ | y | y.next_expiry{ y.expiry } }
+
+      myself =  con_id.to_i.zero? ? self.verify.first  : self
+      error "Cannot roll option; target is no IB::Contract" unless new_option.is_a? IB::Option
+      error "Cannot roll option; Option cannot be verified" unless myself.is_a? IB::Option
+      target = IB::Spread.new exchange: exchange, symbol: symbol, currency: currency
+      target.add_leg myself, action:  :buy
+      target.add_leg new_option, action: :sell
+      target.description= target.description.sub(/added <Option:/, 'rolling <Option:').then{|y| y.gsub /added <Option/, 'to <Option'}
+      target
+    end
+  end
+
+  Connection.current.activate_plugin 'verify'
+
+  class Future
+    include RollFuture
+  end
+
+  class Option
+    include RollOption
+  end
+end

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

@@ -0,0 +1,77 @@
+module IB
+
+    module  Butterfly
+
+      extend SpreadPrototype
+      class << self
+
+        #  Fabricate a Butterfly from Scratch
+        #  -----------------------------------------
+        #
+        #
+        #
+        #   Call with
+        #   IB::Butterfly.fabricate  IB::Option.new( symbol: :estx50, strike: 3000, expiry:'201901'),
+        #                           front: 2850, back: 3150
+        #
+        #   or
+        #   IB::Butterfly.build  from: Symbols::Index.stoxx
+        #                         strike: 3000
+        #                         expiry: '201901', front: 2850, back: 3150
+        #
+        #   where :strike defines the center of the Spread.
+        def  fabricate master, front:, back:
+
+          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
+          if l.empty?
+            error "Invalid Parameters. No Contract found #{master.to_human}"
+          elsif l.size > 1
+            error "ambigous contract-specification: #{l.map(&:to_human).join(';')}"
+            available_trading_classes = l.map( &:trading_class ).uniq
+            if available_trading_classes.size >1
+              error "Refine Specification with trading_class: #{available_trading_classes.join('; ')} "
+            else
+              error "Respecify expiry, verification reveals #{l.size} contracts  (only 1 is allowed)"
+            end
+          end
+
+          initialize_spread( master ) do | the_spread |
+            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.first.essential
+              the_spread.add_leg  leg,  action: action,  ratio: ratio.abs
+            end
+            the_spread.description =  the_description( the_spread )
+            the_spread.symbol = master.symbol
+          end
+        end
+
+        def  build from: , front:, back:,  **options
+          underlying_attributes =  { expiry: IB::Future.next_expiry, right: :put }.merge( from.attributes.slice( :symbol, :currency, :exchange, :strike )).merge( options )
+          fabricate  IB::Option.new( underlying_attributes), front: front, back: back
+        end
+
+        def the_description spread
+      x= [ spread.combo_legs.map(&:weight) , spread.legs.map( &:strike )].transpose
+       "<Butterfly #{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
+
+        def defaults
+          super.merge expiry: IB::Future.next_expiry,
+                      right: :put
+        end
+
+
+        def requirements
+          super.merge back: "the strike of the lower bougth option",
+                      front: "the strike of the upper bougth option"
+
+        end
+
+      end # class
+    end # module
+end  # module ib

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

@@ -0,0 +1,97 @@
+module IB
+
+    module  Calendar
+
+      extend SpreadPrototype
+      class << self
+
+
+#  Fabricate a Calendar-Spread from a Master-Option
+#  -----------------------------------------
+#  If one Leg is known, the other is build through replacing the expiry
+#  The second leg is always SOLD !
+#
+#   Call with
+#   IB::Calendar.fabricate  an_option, the_other_expiry
+      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
+        m = master.verify.first
+        error "Argument is a #{master.class}, but Verification failed" unless m.is_a? IB::Contract
+        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
+        the_other_contract =  m.merge( expiry: back ).verify.first
+        error "Verification of second leg failed" unless the_other_contract.is_a? IB::Contract
+        target = IB::Spread.new exchange: m.exchange, symbol: m.symbol, currency: m.currency
+        target.add_leg m, action:  :buy
+        target.add_leg the_other_contract, action: :sell
+
+#        calendar =  m.roll expiry: back
+        error "Initialisation of Legs failed" if target.legs.size != 2
+        target.description =  the_description( target )
+        target  #  return fabricated spread
+      end
+
+
+#  Build  Vertical out of an Underlying
+#  -----------------------------------------
+#  Needed attributes: :strike, :expiry( front: expiry1, back: expiry2 ), right
+#
+#  Optional: :trading_class, :multiplier
+#
+#   Call with
+#   IB::Calendar.build from: IB::Contract,  front: an_expiry,  back: an_expiry,
+#                                           right: {put or call}, strike: a_strike
+      def build from:, front: nil, back: nil, right: :put, strike: nil,  **fields
+        underlying = if from.is_a?  IB::Option
+                       right ||= from.right
+                       front ||= from.expiry
+                       strike ||= from.strike
+                       details = from.verify.first.contract_detail
+                       IB::Contract.new( con_id: details.under_con_id,
+                                        currency: from.currency).verify.first.essential
+                     else
+                       error "missing essential parameter: `strike`" unless strike.present?
+                       from
+                     end
+        error "`front:` and `back:` expiries are required" unless front.present? && back.present?
+        kind = { :front => front, :back => back }
+        initialize_spread( underlying ) do | the_spread |
+          leg_prototype  = IB::Option.new underlying.invariant_attributes.except( :sec_type )
+            .slice( :currency, :symbol, :exchange )
+            .merge(defaults)
+            .merge( fields )
+            .merge( strike: strike )
+          kind[:back] = IB::Spread.transform_distance front, back
+          leg_prototype.sec_type = 'FOP' if underlying.is_a?(IB::Future)
+          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 )  rescue nil
+        end
+      end
+
+      def defaults
+      super.merge right: :put
+#                expiry: IB::Future.next_expiry,
+      end
+
+
+      def the_description spread
+      x= [ spread.combo_legs.map(&:weight) , spread.legs.map( &:last_trading_day )].transpose
+      f_or_o = if spread.legs.first.is_a?(IB::Future)
+                 "Future"
+               else
+                 "#{spread.legs.first.right}(#{spread.legs.first.strike})"
+               end
+      "<Calendar #{spread.symbol} #{f_or_o} [#{x.map{|w,l_t_d| "#{w}:#{Date.parse(l_t_d).strftime("%b %Y")}"}.join( '|+|' )}]>"
+      end
+     end # class
+    end # module vertical
+end  # module ib

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

@@ -0,0 +1,56 @@
+module IB
+
+    module   StockSpread
+      extend SpreadPrototype
+      class << self
+
+        #  Fabricate a StockSpread from Scratch
+        #  -----------------------------------------
+        #
+        #
+        #
+        #   Call with
+        #   IB::StockSpread.fabricate  'GE','F', ratio:[1,-2]
+        #
+        #   or
+        #   IB::StockSpread.fabricate  IB::Stock.new(symbol:'GE'), 'F', ratio:[1,-2]
+        #
+        #
+        #
+        def  fabricate *underlying,  ratio: [1,-1], **args
+          #
+          are_stocks =  ->(l){ l.all?{|y| y.is_a? IB::Stock} }
+          legs = underlying.map do | the_stock |
+             if the_stock.is_a? IB::Stock
+                the_stock
+             else
+                IB::Stock.new symbol: the_stock
+             end.merge( **args ).verify.first
+          end
+
+          error "only spreads with two underyings of type »IB::Stock« are supported" unless legs.size==2 && are_stocks[legs]
+          
+          initialize_spread( legs.first ) do | the_spread |
+            c_l = legs.zip(ratio).map do |l,r|
+              action = r >0 ?  :buy : :sell
+              the_spread.add_leg  l,  action: action,  ratio: r.abs
+            end
+            the_spread.description =  the_description( the_spread )
+            the_spread.symbol = legs.map( &:symbol ).sort.join(",")  # alphabetical order
+            the_spread.combo_params =  {'NonGuaranteed' => true} 
+          end
+        end
+
+        def the_description spread
+          info=  spread.legs.map( &:symbol ).zip(spread.combo_legs.map( &:weight ))
+          "<StockSpread #{info.map{|c| c.join(":")}.join(" , ")} (#{spread.currency} )>"
+
+        end
+
+        # always route a order as NonGuaranteed
+        def order_requirements
+        end
+
+      end # class
+    end # module
+end  # module ib

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

@@ -0,0 +1,70 @@
+module IB
+    module  Straddle
+      extend SpreadPrototype
+      class << self
+
+
+#  Fabricate a Straddle from a Master-Option
+#  -----------------------------------------
+#  If one Leg is known, the other is simply build by flipping the right
+#
+#   Call with
+#   IB::Spread::Straddle.fabricate an_option
+      def fabricate master
+
+        flip_right = ->(the_right){  the_right == :put ? :call : :put   }
+        error "Argument must be a IB::Option" unless [ :option, :futures_option ].include?( master.sec_type )
+
+        initialize_spread( master ) do | the_spread |
+          the_spread.add_leg master.essential.verify.first
+          the_spread.add_leg( master.essential.merge( right: flip_right[master.right], local_symbol: "").verify.first )
+          error "Initialisation of Legs failed" if the_spread.legs.size != 2
+          the_spread.description =  the_description( the_spread )
+        end
+      end
+
+#  Build  Straddle out of an Underlying
+#  -----------------------------------------
+#  Needed attributes: :strike, :expiry
+#
+#  Optional: :trading_class, :multiplier
+#
+#   Call with
+#   IB::Spread::Straddle.build from: IB::Contract, strike: a_value, expiry: yyyymmm(dd)
+      def build from:, ** fields
+        if  from.is_a?  IB::Option
+          fabricate from.merge **fields
+        else
+          initialize_spread( from ) do | the_spread |
+            leg_prototype  = IB::Option.new from.attributes
+            .slice( :currency, :symbol, :exchange, :expiry)   # use only these fields
+            .merge(defaults)                                  # add defaults
+            .merge( fields )                                  # override attributes with parameters
+#            puts leg_prototype.attributes
+
+            leg_prototype.sec_type = 'FOP' if from.is_a?( IB::Future )
+            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
+        end
+      end
+
+      def defaults
+        super.merge expiry: IB::Option.next_expiry
+      end
+
+      def requirements
+        super.merge strike: "the strike of both options",
+                    expiry: "Expiry expressed as »yyyymm(dd)« (String or Integer)"
+      end
+
+      def the_description spread
+        my_strike =  spread.legs.first.strike
+       "<Straddle #{spread.symbol}(#{my_strike})[#{Date.parse(spread.legs.first.expiry).strftime("%b %Y")}]>"
+      end
+
+      end # class
+    end # module combo
+end  # module ib