ib-extensions 1.0

data/lib/ib/order_prototypes/pegged.rb

@@ -0,0 +1,173 @@
+module IB
+    module  Pegged2Primary
+      extend OrderPrototype
+      class << self
+
+    def defaults
+	  super.merge order_type: 'REL' , 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' 
+    end
+
+      def aliases
+	Limit.aliases.merge  limit_price: :stock_reference_price
+      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 limit_price: 'Stock Reference Price',
+	   stock_ref_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.
+	------------
+	Supported Exchanges: (as of Jan 2018):  BOX, NASDAQOM, PHLX
+	HERE
+      end
+      end
+    end
+
+    module  Pegged2Benchmark
+      extend OrderPrototype
+      class << self
+
+    def defaults
+	  super.merge order_type: 'PEG BENCH' 
+    end
+
+
+
+
+
+      def requirements
+	super.merge total_quantity: :decimal, 
+		    delta: 'required Delta of the Option', 
+		    starting_price: 'initial Limit-Price for the Option' ,
+		    is_pegged_change_amount_decrease: 'increase(true) / decrease(false) Price',
+		    pegged_change_amount: ' (increase/decrceas) 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',
+		    reference_exchange: "Exchange of the reference contract"
+
+
+		  
+
+
+      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'
+      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/lib/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/lib/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/lib/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/lib/ib/spread-prototypes.rb

@@ -0,0 +1,62 @@
+require 'ib/models/spread'
+require 'ib/verify'
+# These modules are used to facilitate referencing of most common Spreads 
+
+# 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 IB
+	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)
+			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
+
+end
+require 'ib/spread_prototypes/straddle'
+require 'ib/spread_prototypes/strangle'
+require 'ib/spread_prototypes/vertical'
+require 'ib/spread_prototypes/calendar'
+require 'ib/spread_prototypes/stock-spread'
+require 'ib/spread_prototypes/butterfly'