public static int Main(string[] args) { Console.WriteLine("Thread {0}: Starting...", Thread.CurrentThread.ManagedThreadId); using (var ibClient = new IbClient()) { try { ProcessContractDetails(ibClient); ibClient.Connect("127.0.0.1", 7496, 0); //We can request the whole option's chain by giving a brief description of the contract //i.e. we only specify symbol, currency, secType and exchange (SMART) Contract optionContract = ContractSamples.getOptionForQuery(); var endContractDetailsTask = ibClient.Response.ContractDetailsEndAsync(); ibClient.Request.ReqContractDetails(1, optionContract); endContractDetailsTask.Wait(); Console.WriteLine("Finished receiving all matching contracts."); Thread.Sleep(1000); Console.WriteLine("Disconnecting..."); } catch (Exception e) { Console.WriteLine(e); } } return(0); }
CurrentBullPuts(string symbol, double strikeLevel, int expirationDaysSkip, int count, int gap) { return ( from cd in IbClient.ReqContractDetailsCached(symbol) from price in IbClient.ReqPriceSafe(cd.Summary, 5, false).Select(p => p.ask.Avg(p.bid)) from combo in MakeBullPuts(symbol, strikeLevel.IfNaN(price), expirationDaysSkip, 1, count, gap) from p in IbClient.ReqPriceSafe(combo.contract, 2, true).DefaultIfEmpty() let strikeAvg = combo.options.Average(o => o.Strike) select ( instrument: combo.contract.Instrument, p.bid, p.ask, p.time,//.ToString("HH:mm:ss"), delta: p.ask.Avg(p.bid) - combo.options.Sum(o => o.IntrinsicValue(price)), strikeAvg, price, breakEven: (up: strikeAvg + price, dn: strikeAvg - price), combo )).ToArray() .Select(b => b .OrderByDescending(t => t.delta) //.Select((t, i) => (t, i)) //.OrderBy(t => t.i > 1) //.ThenBy(t => t.t.ask.Avg(t.t.bid) / t.t.delta) //.ThenByDescending(t => t.t.delta) //.Select(t => t.t) .ToArray() ); }
/// <summary> /// release API /// освободить апи /// </summary> public void Dispose() { if (_client != null) { _client.ConnectionFail -= _ibClient_ConnectionFail; _client.ConnectionSucsess -= _ibClient_ConnectionSucsess; _client.LogMessageEvent -= SendLogMessage; _client.NewAccauntValue -= _ibClient_NewAccauntValue; _client.NewPortfolioPosition -= _ibClient_NewPortfolioPosition; _client.NewContractEvent -= _ibClient_NewContractEvent; _client.NewMarketDepth -= _ibClient_NewMarketDepth; _client.NewMyTradeEvent -= _ibClient_NewMyTradeEvent; _client.NewOrderEvent -= _ibClient_NewOrderEvent; _client.NewTradeEvent -= AddTick; _client.CandlesUpdateEvent -= _client_CandlesUpdateEvent; _client.Disconnect(); } _namesSubscribleSecurities = new List <string>(); _client = null; _connectedContracts = new List <string>(); ServerStatus = ServerConnectStatus.Disconnect; if (DisconnectEvent != null) { DisconnectEvent(); } }
public static int Main(string[] args) { Console.WriteLine("Thread {0}: Starting...", Thread.CurrentThread.ManagedThreadId); using (var ibClient = new IbClient()) { try { // these methods replace the EWrapperImpl class so you only need to implement handlers for what you care about ProcessErrors(ibClient); ProcessTickPrices(ibClient); ProcessTickSizes(ibClient); Console.WriteLine("Connecting to IB..."); ibClient.Connect("127.0.0.1", 7496, 0); var t = ibClient.Response.CurrentTimeAsync(); ibClient.Request.ReqCurrentTime(); t.Wait(); // get time from server synchronously by waiting on the Task to complete Console.WriteLine("Thread {0}: Server time is {1}", Thread.CurrentThread.ManagedThreadId, t.Result); // test IB methods asynchronously TestIbMethods(ibClient); Console.ReadLine(); Console.WriteLine("Disconnecting..."); } catch (Exception e) { Console.WriteLine(e); } } return(0); }
private static async void ProcessTickPrices(IbClient ibClient) { while (true) { var tickPrice = await ibClient.Response.TickPriceAsync(); Console.WriteLine("Thread {0}: Tick Price. Ticker Id: {1}, Field: {2}, Price: {3}, CanAutoExecute: {4}", Thread.CurrentThread.ManagedThreadId, tickPrice.TickerId, tickPrice.Field, tickPrice.Price, tickPrice.CanAutoExecute); } }
private static async void ProcessTickSizes(IbClient ibClient) { while (true) { var tickSize = await ibClient.Response.TickSizeAsync(); Console.WriteLine("Thread {0}: Tick Size. Ticker Id: {1}, Field: {2}, Size: {3}", Thread.CurrentThread.ManagedThreadId, tickSize.TickerId, tickSize.Field, tickSize.Size); } }
public static void PlaceOrder(IbClient wrapper, Order order, Contract contract) { order.OrderId = wrapper.NextOrderId; wrapper.ClientSocket.placeOrder(order.OrderId, (contract ?? futureComboContract), order); //it does not really matter how fast this method execute since //this is only used when for limit/stop when rolling over contracts //so lets add random delay to ensure no problems with order ids AddRandomDelay(); }
public SimplestNetStrategy(IbClient wrapper, MyAppSettings settings) { this.wrapper = wrapper; this.settings = settings; InitialiseClients(); GetInstrumentAndContract(); }
public static void PlaceMarketOrder(Contract contract, double i, IbClient wrapper) { if (i >= 1) { MakeMktTrade("BUY", wrapper, contract, "MKT", i); } else if (i <= -1) { MakeMktTrade("SELL", wrapper, contract, "MKT", i); } }
public COMBO_TRADES ComboTrades(double priceTimeoutInSeconds) { var combos = ( from c in ComboTradesImpl().ToObservable() from underPrice in UnderPrice(c.contract).DefaultIfEmpty() from price in IbClient.ReqPriceSafe(c.contract, priceTimeoutInSeconds, true).DefaultIfEmpty().Take(1) let multiplier = c.contract.ComboMultiplier let closePrice = (c.position > 0 ? price.bid : price.ask) let close = (closePrice * c.position * multiplier).Round(4) let openPrice = c.open / c.position.Abs() / multiplier let isOk = openPrice == c.openPrice ? true : throw new Exception(new { calc = new { openPrice }, c.openPrice } +"") let pmc = Account.ExcessLiquidity / (multiplier * c.position.Abs()) select( c: IbClient.SetContractSubscription(c.contract) , c.position , c.open , close , pl: close - c.open , underPrice , strikeAvg: c.contract.ComboStrike() , openPrice , closePrice , price: (price.bid, price.ask) , c.takeProfit , profit: (c.takeProfit * c.position * multiplier - c.open).Round(2) , pmc , c.orderId ) ); return(combos .ToArray() .SelectMany(cmbs => cmbs .OrderBy(c => c.c.Legs().Count()) .ThenBy(c => c.c.IsOption) .ThenByDescending(c => c.strikeAvg - c.underPrice) .ThenByDescending(c => c.c.Instrument) )); IObservable <double> UnderPrice(Contract contract) { if (!contract.IsOption && !contract.IsCombo) { return(Observable.Return(0.0)); } var underSymbol = contract.Symbol + (contract.HasFutureOption ? "U8" : ""); return( from symbol in IbClient.ReqContractDetailsCached(underSymbol) from underPrice in IbClient.ReqPriceSafe(symbol.Summary, priceTimeoutInSeconds, false) select underPrice.ask.Avg(underPrice.bid)); } }
private static async void ProcessErrors(IbClient ibClient) { while (true) { var error = await ibClient.Response.ErrorAsync(); Console.WriteLine("Thread {0}: Error - {1}", Thread.CurrentThread.ManagedThreadId, error.ErrorMessage); if (error.Exception != null) { Console.WriteLine(error.Exception); } } }
public IEnumerable <(Contract contract, int position, double open, double openPrice, double takeProfit, int orderId)> ComboTradesImpl() { var positions = Positions.Where(p => p.position != 0).ToArray(); var orders = OrderContractsInternal.Where(oc => !oc.isDone).ToArray(); var combos = ( from c in positions /*.ParseCombos(orders)*/.Do(c => IbClient.SetContractSubscription(c.contract)) let order = orders.Where(oc => oc.isSubmitted && oc.contract.Key == c.contract.Key).Select(oc => (oc.order.OrderId, oc.order.LmtPrice)).FirstOrDefault() select(c.contract, c.position, c.open, c.open / c.position.Abs() / c.contract.ComboMultiplier, order.LmtPrice, order.OrderId) ); var comboAll = ComboTradesAllImpl().ToArray(); return(combos.Concat(comboAll).Distinct(c => c.contract.Instrument)); }
/*****************************************************************/ /* Below are few quick-to-test examples on the IB API functions. * Process methods, like the ones above, will need to implemented to process responses generated from these request methods. * See the IB API Reference to determine which methods will receive responses for a particular request. */ /*****************************************************************/ private static void TestIbMethods(IbClient ibClient) { /***************************************************/ /*** Real time market data operations - Tickers ***/ /***************************************************/ /*** Requesting real time market data ***/ //ibClient.Request.ReqMarketDataType(2); //ibClient.Request.ReqMktData(1001, ContractSamples.getEurUsdForex(), "", false, GetFakeParameters(3)); //ibClient.Request.ReqMktData(1002, ContractSamples.getOption(), "", false, GetFakeParameters(3)); //ibClient.Request.ReqMktData(1003, ContractSamples.getEuropeanStock(), "", false, GetFakeParameters(3)); //Thread.Sleep(2000); /*** Canceling the market data subscription ***/ //ibClient.Request.CancelMktData(1001); //ibClient.Request.CancelMktData(1002); //ibClient.Request.CancelMktData(1003); /********************************************************/ /*** Real time market data operations - Market Depth ***/ /********************************************************/ /*** Requesting the Deep Book ***/ //ibClient.Request.ReqMktDepth(2001, ContractSamples.getEurGbpForex(), 5, GetFakeParameters(2)); //Thread.Sleep(2000); /*** Canceling the Deep Book request ***/ //ibClient.Request.CancelMktDepth(2001); /**********************************************************/ /*** Real time market data operations - Real Time Bars ***/ /**********************************************************/ /*** Requesting real time bars ***/ //ibClient.Request.ReqRealTimeBars(3001, ContractSamples.getEurGbpForex(), -1, "MIDPOINT", true, GetFakeParameters(4)); //Thread.Sleep(2000); /*** Canceling real time bars ***/ //ibClient.Request.CancelRealTimeBars(3001); /**********************************/ /*** Historical Data operations ***/ /**********************************/ /*** Requesting historical data ***/ //ibClient.Request.ReqHistoricalData(4001, ContractSamples.getEurGbpForex(), "20130722 23:59:59", "1 D", "1 min", "MIDPOINT", 1, 1, GetFakeParameters(4)); //ibClient.Request.ReqHistoricalData(4002, ContractSamples.getEuropeanStock(), "20131009 23:59:59", "10 D", "1 min", "TRADES", 1, 1, null); /*** Canceling historical data requests ***/ //ibClient.Request.CancelHistoricalData(4001); //ibClient.Request.CancelHistoricalData(4002); /****************************/ /*** Contract information ***/ /****************************/ //ibClient.Request.ReqContractDetails(6001, ContractSamples.GetbyIsin()); //ibClient.Request.ReqContractDetails(210, ContractSamples.getOptionForQuery()); //ibClient.Request.ReqContractDetails(211, ContractSamples.GetBondForQuery()); }
/// <summary> /// Trades the specified contract. /// </summary> /// <param name="contract">The contract.</param> /// <param name="direction"></param> /// <param name="wrapper"></param> /// <param name="type"></param> /// <param name="quantity"></param> private static void MakeMktTrade(string direction, IbClient wrapper, Contract contract = null, string type = "MKT", double quantity = 1) { var order = new Order { Action = direction, OrderType = type, Account = wrapper.AccountNumber, TotalQuantity = Math.Abs(quantity), OrderId = wrapper.NextOrderId, Tif = "GTC" }; wrapper.ClientSocket.placeOrder(order.OrderId, (contract ?? futureComboContract), order); }
public static async void ProcessContractDetails(IbClient ibClient) { while (true) { var contractDetailsMsg = await ibClient.Response.ContractDetailsAsync(); var contractDetails = contractDetailsMsg.ContractDetails; Console.WriteLine("/*******Incoming Contract Details - RequestId " + contractDetailsMsg.ReqId + "************/"); Console.WriteLine(contractDetails.Summary.Symbol + " " + contractDetails.Summary.SecType + " @ " + contractDetails.Summary.Exchange); Console.WriteLine("Expiry: " + contractDetails.Summary.Expiry + ", Right: " + contractDetails.Summary.Right); Console.WriteLine("Strike: " + contractDetails.Summary.Strike + ", Multiplier: " + contractDetails.Summary.Multiplier); Console.WriteLine("/******* End *************/\n"); } }
public static void MakeLmtTrade( IbClient wrapper, double price = 3000, Contract contract = null, int quantity = 1, string direction = "SELL", string type = "LMT") { var order = new Order { Action = direction, OrderType = type, LmtPrice = price, Account = wrapper.AccountNumber, TotalQuantity = quantity, OrderId = wrapper.NextOrderId, Tif = "GTC" }; wrapper.ClientSocket.placeOrder(order.OrderId, (contract ?? futureComboContract), order); }
CurrentStraddles(string symbol, double strikeLevel, int expirationDaysSkip, int count, int gap) { return(( from cd in IbClient.ReqContractDetailsCached(symbol) from price in IbClient.ReqPriceSafe(cd.Summary, 5, false).Select(p => p.ask.Avg(p.bid)) from combo in MakeStraddles(symbol, strikeLevel.IfNaN(price), expirationDaysSkip, 1, count, gap) from p in IbClient.ReqPriceSafe(combo.contract, 2, true).DefaultIfEmpty() select CurrentComboInfo(price, combo, p)).ToArray() .Select(b => b .OrderBy(t => t.ask.Avg(t.bid)) .Select((t, i) => ((t, i))) .OrderBy(t => t.i > 1) .ThenBy(t => t.t.ask.Avg(t.t.bid) / t.t.delta) .ThenByDescending(t => t.t.delta) .Select(t => t.t) .ToArray() )); }
/// <summary> /// connect to API /// подсоединиться к апи /// </summary> public void Connect() { if (_client == null) { _client = new IbClient(); _client.ConnectionFail += _ibClient_ConnectionFail; _client.ConnectionSucsess += _ibClient_ConnectionSucsess; _client.LogMessageEvent += SendLogMessage; _client.NewAccauntValue += _ibClient_NewAccauntValue; _client.NewPortfolioPosition += _ibClient_NewPortfolioPosition; _client.NewContractEvent += _ibClient_NewContractEvent; _client.NewMarketDepth += _ibClient_NewMarketDepth; _client.NewMyTradeEvent += _ibClient_NewMyTradeEvent; _client.NewOrderEvent += _ibClient_NewOrderEvent; _client.NewTradeEvent += AddTick; _client.CandlesUpdateEvent += _client_CandlesUpdateEvent; } _client.Connect( ((ServerParameterString)ServerParameters[0]).Value, ((ServerParameterInt)ServerParameters[1]).Value); }
public void OpenLimitOrder(Contract contract, int quantity, double profit, bool useMarketPrice, bool useTakeProfit, int minTickMultiplier = 1, [CallerMemberName] string Caller = "") { double ask((double ask, double bid, DateTime time) p) => useMarketPrice ? p.ask : p.bid; double bid(double a, double b) => useMarketPrice ? b : a; IbClient.ReqPriceSafe(contract, 1, true).Select(p => quantity > 0 ? ask(p) : bid(p.ask, p.bid)) .Subscribe(price => OpenTrade(contract, "", quantity, price, profit, useTakeProfit, DateTime.MaxValue, minTickMultiplier, Caller)); }