ib-api 10.33.1

data/plugins/ib/order-prototypes/market.rb

@@ -0,0 +1,116 @@
+
+module IB
+#  module OrderPrototype
+    module  Market
+      extend OrderPrototype
+      class << self
+
+      def defaults
+    super.merge order_type: 'MKT' , tif: :day
+      end
+
+      def aliases
+  super 
+      end
+
+      def requirements
+  super 
+      end
+
+
+      def summary
+  <<-HERE
+   A Market order is an order to buy or sell at the market bid or offer price.
+   A market order may increase the likelihood of a fill and the speed of execution,
+   but unlike the Limit order a Market order provides no price protection and
+   may fill at a price far lower/higher than the current displayed bid/ask.
+  HERE
+      end
+      end
+    end
+    module  MarketIfTouched
+      extend OrderPrototype
+      class << self
+
+      def defaults
+    super.merge order_type: 'MIT' , tif: :day
+      end
+
+      def aliases
+  super 
+      end
+
+      def requirements
+  super 
+      end
+
+
+      def summary
+  <<-HERE
+  A Market if Touched (MIT) is an order to buy (or sell) a contract below (or above) the market.
+  Its purpose is to take advantage of sudden or unexpected changes in share or other prices and
+  rovides investors with a trigger price to set an order in motion.
+  Investors may be waiting for excessive strength (or weakness) to cease, which might be represented
+  by a specific price point.
+  MIT orders can be used to determine whether or not to enter the market once a specific price level 
+  has been achieved. This order is held in the system until the trigger price is touched, and
+  is then submitted as a market order. An MIT order is similar to a stop order, except that an MIT 
+  sell order is placed above the current market price, and a stop sell order is placed below.
+  HERE
+      end
+      end
+    end
+
+
+    module  MarketOnClose
+      extend OrderPrototype
+      class << self
+
+      def defaults
+    super.merge order_type: 'MOC' , tif: :day
+      end
+
+      def aliases
+  super 
+      end
+
+      def requirements
+  super 
+      end
+
+
+      def summary
+  <<-HERE
+  A Market-on-Close (MOC) order is a market order that is submitted to execute as close
+  to the closing price as possible.
+  HERE
+      end
+      end
+    end
+    
+    module  MarketOnOpen
+      extend OrderPrototype
+      class << self
+
+      def defaults
+    super.merge order_type: 'MOC' , tif: :opening_price
+      end
+
+      def aliases
+  super 
+      end
+
+      def requirements
+  super 
+      end
+
+
+      def summary
+  <<-HERE
+  A Market-on-Close (MOC) order is a market order that is submitted to execute as close
+  to the closing price as possible.
+  HERE
+      end
+      end
+    end
+end

data/plugins/ib/order-prototypes/pegged.rb

@@ -0,0 +1,169 @@
+module IB
+    module  Pegged2Primary
+      extend OrderPrototype
+      class << self
+
+    def defaults
+    super.merge order_type: :pegged_to_primary , tif: :day
+    end
+
+      def aliases
+  super.merge  limit_price: :price_cap,
+                 aux_price: :offset_amount
+      end
+
+      def requirements
+  super.merge aux_price: 'also aliased as :offset_amount',
+        limit_price: 'aliased as :price_cap'
+      end
+
+      def optional
+   super
+      end
+
+      def summary
+  <<-HERE
+  Relative (a.k.a. Pegged-to-Primary) orders provide a means for traders
+  to seek a more aggressive price than the National Best Bid and Offer
+  (NBBO). By acting as liquidity providers, and placing more aggressive
+  bids and offers than the current best bids and offers, traders increase
+  their odds of filling their order. Quotes are automatically adjusted as
+  the markets move, to remain aggressive. For a buy order, your bid is
+  pegged to the NBB by a more aggressive offset, and if the NBB moves up,
+  your bid will also move up. If the NBB moves down, there will be no
+  adjustment because your bid will become even more aggressive and
+  execute. For sales, your offer is pegged to the NBO by a more
+  aggressive offset, and if the NBO moves down, your offer will also move
+  down. If the NBO moves up, there will be no adjustment because your
+  offer will become more aggressive and execute. In addition to the
+  offset, you can define an absolute cap, which works like a limit price,
+  and will prevent your order from being executed above or below a
+  specified level. 
+  Supported Products:  Stocks, Options and Futures
+  ------ 
+  not available on paper trading 
+  HERE
+      end
+      end
+    end
+    module  Pegged2Market
+      extend OrderPrototype
+      class << self
+
+    def defaults
+    super.merge order_type: 'PEG MKT' , tif: :day
+    end
+
+      def aliases
+  Limit.aliases.merge  aux_price: :market_offset
+      end
+
+      def requirements
+  super.merge aux_price: :decimal
+      end
+
+      def optional
+   super
+      end
+
+      def summary
+  <<-HERE
+  A pegged-to-market order is designed to maintain a purchase price relative to the
+  national best offer (NBO) or a sale price relative to the national best bid (NBB).
+  Depending on the width of the quote, this order may be passive or aggressive.
+  The trader creates the order by entering a limit price which defines the worst limit
+  price that they are willing to accept.
+  Next, the trader enters an offset amount which computes the active limit price as follows:
+     Sell order price = Bid price + offset amount
+     Buy order price = Ask price - offset amount
+  HERE
+      end
+      end
+    end
+
+    module  Pegged2Stock
+      extend OrderPrototype
+      class << self
+
+    def defaults
+      super.merge order_type: 'PEG STK', tif: :day
+    end
+
+      def requirements
+        super.merge total_quantity: :decimal,
+                             delta: 'required Delta of the Option',
+                    starting_price: 'initial Limit-Price for the Option'
+      end
+
+      def optional
+   super.merge stock_ref_price:  'Stock Reference Price',
+             stock_range_lower: 'Lowest acceptable Stock Price',
+             stock_range_upper: 'Highest accepable Stock Price'
+      end
+
+      def summary
+  <<-HERE
+  Options ONLY
+  ------------
+  A Pegged to Stock order continually adjusts the option order price by the product of a signed user-
+  defined delta and the change of the option's underlying stock price. 
+  The delta is entered as an absolute and assumed to be positive for calls and negative for puts.
+  A buy or sell call order price is determined by adding the delta times a change in an underlying stock
+  price to a specified starting price for the call.
+  To determine the change in price, the stock reference price is subtracted from the current NBBO 
+  midpoint. The Stock Reference Price can be defined by the user, or defaults to the 
+  the NBBO midpoint at the time of the order if no reference price is entered.
+  You may also enter a high/low stock price range which cancels the order when reached. The 
+  delta times the change in stock price will be rounded to the nearest penny in favor of the order.
+  ------------
+  HERE
+      end
+      end
+    end
+
+    module  Pegged2Benchmark
+      extend OrderPrototype
+      class << self
+
+        def defaults
+          super.merge             order_type: :pegged_to_benchmark,
+            is_pegged_change_amount_decrease: false,
+                                         tif: :day
+        end
+
+        def requirements
+          super.merge total_quantity: :decimal,
+                      starting_price: 'initial Limit-Price for the contract to trade' ,
+                pegged_change_amount: ' (increase/decrease) by... (and likewise for price moving in opposite direction)',
+             reference_change_amount: ' ... whenever there is a price change of...',
+               reference_contract_id: 'the conid of the reference contract'
+        end
+
+        def aliases
+          super.merge  reference_change_amount: :reference_change_by,
+                          pegged_change_amount: :change_by,
+              is_pegged_change_amount_decrease: :decrease,
+                         reference_contract_id: :reference
+
+        end
+
+
+        def optional
+          super.merge stock_ref_price: 'starting price of the reference contract',
+                    stock_range_lower: 'Lowest acceptable  Price of the reference contract',
+                    stock_range_upper: 'Highest accepable  Price of the reference contract',
+     is_pegged_change_amount_decrease: 'increase(true) / decrease(false) Price (default: false)',
+                reference_exchange_id: "Exchange of the reference contract"
+        end
+
+        def summary
+          <<-HERE
+  The Pegged to Benchmark order is similar to the Pegged to Stock order for options, 
+  except that the Pegged to Benchmark allows you to specify any asset type as the 
+  reference (benchmark) contract for a stock or option order. Both the primary and 
+  reference contracts must use the same currency. 
+          HERE
+        end
+      end
+    end
+end

data/plugins/ib/order-prototypes/premarket.rb

@@ -0,0 +1,31 @@
+module IB
+#  module OrderPrototype
+    module AtAuction
+      extend OrderPrototype
+      class << self
+
+      def defaults
+  { order_type: 'MTL' , tif: "AUC"}
+      end
+
+      def aliases
+  super.merge  limit_price: :price 
+      end
+
+      def requirements
+  super.merge limit_price: :decimal 
+      end
+
+
+      def summary
+  <<-HERE
+  An auction order is entered into the electronic trading system during the pre-market
+  opening period for execution at the Calculated Opening Price (COP).
+  If your order is not filled on the open, the order is re-submitted as a
+  limit order with the limit price set to the COP or the best bid/ask after the market opens.
+  Products: FUT, STK
+  HERE
+      end
+      end
+    end
+end

data/plugins/ib/order-prototypes/stop.rb

@@ -0,0 +1,202 @@
+
+module IB
+    module SimpleStop
+      extend OrderPrototype
+      class << self
+
+      def defaults
+    super.merge order_type: :stop 
+      end
+
+      def aliases
+  super.merge  aux_price: :price 
+      end
+
+      def requirements
+  super.merge aux_price: 'Price where the action is triggert. Aliased as :price'
+      end
+
+
+      def summary
+  <<-HERE
+  A Stop order is an instruction to submit a buy or sell market order if and when the 
+  user-specified stop trigger price is attained or penetrated. A Stop order is not guaranteed 
+  a specific execution price and may execute significantly away from its stop price. 
+  
+  A Sell Stop order is always placed below the current market price and is typically used 
+  to limit a loss or protect a profit on a long stock position. 
+  
+  A Buy Stop order is always placed above the current market price. It is typically used 
+  to limit a loss or help protect a profit on a short sale. 
+  HERE
+      end
+      end
+    end
+    module StopLimit
+      extend OrderPrototype
+      class << self
+
+      def defaults
+    super.merge order_type: :stop_limit 
+      end
+
+      def aliases
+  Limit.aliases.merge  aux_price: :stop_price
+      end
+
+      def requirements
+  Limit.requirements.merge aux_price: 'Price where the action is triggert. Aliased as :stop_price'
+      end
+
+
+      def summary
+  <<-HERE
+  A Stop-Limit order is an instruction to submit a buy or sell limit order when 
+  the user-specified stop trigger price is attained or penetrated. The order has 
+  two basic components: the stop price and the limit price. When a trade has occurred 
+  at or through the stop price, the order becomes executable and enters the market 
+  as a limit order, which is an order to buy or sell at a specified price or better. 
+  HERE
+      end
+      end
+    end
+    module  StopProtected
+      extend OrderPrototype
+      class << self
+
+      def defaults
+    super.merge order_type: :stop_protected 
+      end
+
+      def aliases
+  SimpleStop.aliases
+      end
+
+      def requirements
+  SimpleStop.requirements
+      end
+
+
+      def summary
+  <<-HERE
+  US-Futures only
+  ----------------------------
+  A Stop with Protection order combines the functionality of a stop limit order 
+  with a market with protection order. The order is set to trigger at a specified 
+  stop price. When the stop price is penetrated, the order is triggered as a 
+  market with protection order, which means that it will fill within a specified 
+  protected price range equal to the trigger price +/- the exchange-defined protection 
+  point range. Any portion of the order that does not fill within this protected 
+  range is submitted as a limit order at the exchange-defined trigger price +/- 
+  the protection points.
+  HERE
+      end
+    end
+    end
+#  module OrderPrototype
+    module  TrailingStop
+      extend OrderPrototype
+      class << self
+
+
+        def defaults
+          super.merge order_type: :trailing_stop , tif: :day
+        end
+
+        def aliases
+          super.merge trail_stop_price: :price,
+                      aux_price: :trailing_amount
+        end
+
+        def requirements
+          ## usualy the trail_stop_price is the market-price minus(plus) the trailing_amount
+          super.merge trail_stop_price: 'Price to trigger the action, aliased as :price'
+
+        end
+
+        def alternative_parameters
+          { aux_price: 'Trailing distance in absolute terms, aliased as :trailing_amount',
+       trailing_percent: 'Trailing distance in relative terms'}
+        end
+
+        def summary
+          <<-HERE
+  A "Sell" trailing stop order sets the stop price at a fixed amount below the market 
+  price with an attached "trailing" amount. As the market price rises, the stop price 
+  rises by the trail amount, but if the stock price falls, the stop loss price doesn't 
+  change, and a market order is submitted when the stop price is hit. This technique 
+  is designed to allow an investor to specify a limit on the maximum possible loss, 
+  without setting a limit on the maximum possible gain. 
+
+  "Buy" trailing stop orders are the mirror image of sell trailing stop orders, and 
+  are most appropriate for use in falling markets.
+
+  Note that Trailing Stop orders can have the trailing amount specified as a percent, 
+  or as an absolute amount which is specified in the auxPrice field. 
+
+          HERE
+        end  # summary
+      end    # class self
+    end     # module
+
+    module TrailingStopLimit
+      extend OrderPrototype
+      class << self
+
+
+        def defaults
+          super.merge order_type: :trailing_limit , tif: :day
+        end
+
+        def aliases
+          Limit.aliases 
+        end
+
+        def requirements
+          super.merge trail_stop_price: 'Price to trigger the action',
+                      limit_price_offset: 'a pRICE'
+
+        end
+
+        def alternative_parameters
+          { aux_price: 'Trailing distance in absolute terms',
+       trailing_percent: 'Trailing distance in relative terms'}
+        end
+
+        def summary
+          <<-HERE
+     A trailing stop limit order is designed to allow an investor to specify a
+     limit on the maximum possible loss, without setting a limit on the maximum
+     possible gain. A SELL trailing stop limit moves with the market price, and
+     continually recalculates the stop trigger price at a fixed amount below
+     the market price, based on the user-defined "trailing" amount. The limit
+     order price is also continually recalculated based on the limit offset. As
+     the market price rises, both the stop price and the limit price rise by
+     the trail amount and limit offset respectively, but if the stock price
+     falls, the stop price remains unchanged, and when the stop price is hit a
+     limit order is submitted at the last calculated limit price. A "Buy"
+     trailing stop limit order is the mirror image of a sell trailing stop
+     limit, and is generally used in falling markets.
+
+     Products: BOND, CFD, CASH, FUT, FOP, OPT, STK, WAR
+          HERE
+        end
+      end
+
+#    def TrailingStopLimit(action:str, quantity:float, lmtPriceOffset:float, 
+#                          trailingAmount:float, trailStopPrice:float):
+#    
+#        # ! [trailingstoplimit]
+#        order = Order()
+#        order.action = action
+#        order.orderType = "TRAIL LIMIT"
+#        order.totalQuantity = quantity
+#        order.trailStopPrice = trailStopPrice
+#        order.lmtPriceOffset = lmtPriceOffset
+#        order.auxPrice = trailingAmount
+#        # ! [trailingstoplimit]
+#        return order
+#
+#
+    end
+end

data/plugins/ib/order-prototypes/volatility.rb

@@ -0,0 +1,39 @@
+module IB
+#  module OrderPrototype
+    module Volatility
+      ### todo : check  again. Order is  siently accepted, but not acknowledged
+      extend OrderPrototype
+      class << self
+
+      def defaults
+  { order_type: :volatility, volatility_type: 2 }  #default is annual volatility
+      end
+
+
+      def requirements
+  super.merge volatility:  "the desired Option implied Vola (in %)"
+      end
+
+      def aliases
+  super.merge volatility: :volatility_percent
+      end
+
+      def summary
+  <<-HERE
+  Investors are able to create and enter Volatility-type orders for options and combinations 
+  rather than price orders. Option traders may wish to trade and position for movements in the 
+  price of the option determined by its implied volatility. Because implied volatility is a key
+  determinant of the premium on an option, traders position in specific contract months in an 
+  effort to take advantage of perceived changes in implied volatility arising before, during or 
+  after earnings or when company specific or broad market volatility is predicted to change. 
+  In order to create a Volatility order, clients must first create a Volatility Trader page from 
+  the Trading Tools menu and as they enter option contracts, premiums will display in percentage 
+  terms rather than premium. The buy/sell process is the same as for regular orders priced in 
+  premium terms except that the client can limit the volatility level they are willing to pay or receive.
+  --------
+  Products: FOP, OPT
+  HERE
+      end
+      end
+    end
+end

data/plugins/ib/order-prototypes.rb

@@ -0,0 +1,118 @@
+module IB
+=begin rdoc
+
+Plugin to build IB::Order objects through singletons
+
+Public API
+==========
+
+Creates IB::Order objects
+
+
+* IB::<OrderPrototye>.order params
+* IB::<OrderPrototye>.summary
+* IB::<OrderPrototye>.parameters
+
+=end
+
+  module OrderPrototype
+
+
+#The Module OrderPrototypes provides a wrapper to define even complex ordertypes.
+#
+#The Order is build by
+#
+# IB::<OrderPrototye>.order
+#
+#A description is available through
+#
+# puts IB::<OrderPrototype>.summary
+#
+#Nessesary and optional arguments are printed by
+#
+# puts IB::<OrderPrototype>.parameters
+#
+#Orders can be setup interactively
+#
+#   > d =  Discretionary.order
+#   Traceback (most recent call last): (..)
+#   IB::ArgumentError (IB::Discretionary.order -> A necessary field is missing:
+#         action: --> {"B"=>:buy, "S"=>:sell, "T"=>:short, "X"=>:short_exempt})
+#   > d =  Discretionary.order action: :buy
+#   IB::ArgumentError (IB::Discretionary.order -> A necessary field is missing:
+#         total_quantity: --> also aliased as :size)
+#   > d =  Discretionary.order action: :buy, size: 100
+#         Traceback (most recent call last):
+#   IB::ArgumentError (IB::Discretionary.order -> A necessary field is missing: limit_price: --> decimal)
+#
+#
+#
+#Prototypes are defined as module. They extend OrderPrototype and establish singleton methods, which
+#can adress and extend similar methods from OrderPrototype.
+#
+#
+
+
+
+    def order **fields
+
+      # special treatment of size:  positive numbers --> buy order, negative: sell
+      if fields[:size].present? && fields[:action].blank?
+        error "Size = 0 is not possible" if fields[:size].zero?
+        fields[:action] = fields[:size] >0 ? :buy  : :sell
+        fields[:size] = fields[:size].abs
+      end
+      # change aliases  to the original. We are modifying the fields-hash.
+      fields.keys.each{|x| fields[aliases.key(x)] = fields.delete(x) if aliases.has_value?(x)}
+      # inlcude defaults (arguments override defaults)
+      the_arguments = defaults.merge fields
+      # check if requirements are fullfilled
+      necessary = requirements.keys.detect{|y| the_arguments[y].nil?}
+      if necessary.present?
+        msg =self.name + ".order -> A necessary field is missing: #{necessary}: --> #{requirements[necessary]}"
+        error msg, :args, nil
+      end
+      if alternative_parameters.present?
+        unless ( alternative_parameters.keys  & the_arguments.keys ).size == 1
+          msg =self.name + ".order -> One of the alternative fields needs to be specified: \n\t:" +
+            "#{alternative_parameters.map{|x| x.join ' => '}.join(" or \n\t:")}"
+          error msg, :args, nil
+        end
+      end
+
+      # initialise order with given attributes
+      IB::Order.new **the_arguments
+    end
+
+    def alternative_parameters
+      {}
+    end
+    def requirements
+      { action: IB::VALUES[:side], total_quantity: 'also aliased as :size' }
+    end
+
+    def defaults
+      {  tif: :good_till_cancelled }
+    end
+
+    def optional
+      { account: 'Account(number) to trade on' }
+    end
+
+    def aliases
+      {  total_quantity: :size }
+    end
+
+    def parameters
+      the_output = ->(var){ var.map{|x| x.join(" --> ") }.join("\n\t: ")}
+
+      "Required : " + the_output[requirements] + "\n --------------- \n" +
+        "Optional : " + the_output[optional] + "\n --------------- \n"
+
+    end
+
+  end
+[ :forex, :market, :limit, :stop, :volatility, :premarket, :pegged, :combo, :adaptive ].each do | pt |
+  Connection.current.activate_plugin "order_prototypes/#{pt.to_s}"
+end
+end