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));
}
