public void Publish(MarketTickData marketTickData)
{
var serialize = new BinarySerializer();
var msgInBytes = serialize.Serialize(marketTickData);
base.Publish(msgInBytes);
}
void OnRealTimeTickDataUpdate(string sender, MarketTickData message)
{
//TODO: This depends on the mode of when the trade signal should be run
if (m_TradingModel.IsDaily && !m_IsDailyTradeSignalRan)
{
m_IsDailyTradeSignalRan = true;
RunTradeSignal();
}
if (m_SignalState != TradingModelSignalState.TradeSignal)
{
//signal is already generated, Run Entry/Exit
if (m_SignalState == TradingModelSignalState.TradeEntry)
{
m_TradeEntryInstruction = m_TradingModel.TradeEntry();
if (m_TradeEntryInstruction != null)
{
//add the bar index for entry position
m_TradeEntryInstruction.BarIndex = m_CurrentBarIndex;
m_SignalState = TradingModelSignalState.TradeExit;
//add Trade entry to the money manager
m_moneyMgr.AddTradeEntry(m_TradeEntryInstruction);
}
}
if (m_SignalState == TradingModelSignalState.TradeExit)
{
m_TradeExitInstruction = m_TradingModel.TradeExit(m_TradeEntryInstruction);
if (m_TradeExitInstruction != null)
{
//log the bar index for exit signal
m_TradeExitInstruction.BarIndex = m_CurrentBarIndex;
//add Trade exit to the money manager
m_moneyMgr.AddTradeExit(m_TradeExitInstruction);
//unsubscribe from all events
m_BarDataHandler.BarDataCreatedCompleted -= OnBarDataCreatedCompleted;
m_TickDataHandler.OnRealTimeTickDataUpdate -= OnRealTimeTickDataUpdate;
m_TickDataHandler.OnRealTimeTickDataDateChange -= OnRealTimeTickDataDateChange;
if (CallbackTradePositionCloseReceived != null)
{
CallbackTradePositionCloseReceived.Invoke(m_ref, m_TradeEntryInstruction, m_TradeExitInstruction);
}
}
}
}
if (CallbackTickDataUpdateReceived != null)
{
CallbackTickDataUpdateReceived.Invoke(m_jobId, message, m_CurrentBarIndex);
}
}
private static void Trade2()
{
// get BTC balance
// higest growth rate curr buys lowest growth rate
MarketTickData mdBTC_AUD = BTCMarketsHelper.GetMarketTick($"BTC/AUD");
MarketTickData mdETH_AUD = BTCMarketsHelper.GetMarketTick($"ETH/AUD");
MarketTickData mdETH_BTC = BTCMarketsHelper.GetMarketTick($"ETH/BTC");
BotLogger.WriteLine($",{mdBTC_AUD.bestAsk}, {mdETH_AUD.bestAsk}, {mdETH_BTC.bestAsk}");
}
public void AddRegressionJobTickData(int regressionJobId, int barIndex, MarketTickData tickData)
{
datsys.RegressionJobTickDatas.Add(new RegressionJobTickData
{
RegressionJobId = regressionJobId,
BarIndex = barIndex,
Ask = (float?)(tickData.Ask),
AskQty = (float?)(tickData.AskQty),
Bid = (float?)tickData.Bid,
BidQty = (float?)tickData.BidQty
});
datsys.SaveChanges();
}
private void RunReceive(MarketTickData tickData)
{
try
{
m_currentTickIndex++;
m_TickDatas.TryAdd(m_currentTickIndex, tickData);
TickDataUpdateType tickDataUpdateType = GetUpdateType(tickData);
if (tickDataUpdateType.HasFlag(TickDataUpdateType.Ask))
{
m_TickDataHandlers[TickDataUpdateType.Ask].Add(tickData.Ask);
m_TickDataHandlers[TickDataUpdateType.AskQty].Add(tickData.AskQty);
}
if (tickDataUpdateType.HasFlag(TickDataUpdateType.Bid))
{
m_TickDataHandlers[TickDataUpdateType.Bid].Add(tickData.Bid);
m_TickDataHandlers[TickDataUpdateType.BidQty].Add(tickData.BidQty);
}
if (tickDataUpdateType.HasFlag(TickDataUpdateType.SettlementPrice))
{
m_TickDataHandlers[TickDataUpdateType.SettlementPrice].Add(tickData.SettlementPrice);
m_TickDataHandlers[TickDataUpdateType.SettlementQty].Add(tickData.SettlementQty);
}
if (OnRealTimeTickDataUpdate != null)
{
OnRealTimeTickDataUpdate.Invoke("realtimetickdatahandler", tickData);
}
if (m_PreviousTickData == null)
{
m_PreviousTickData = tickData;
}
if (tickData.DataDate != m_PreviousTickData.DataDate)
//change of date
{
if (OnRealTimeTickDataDateChange != null)
{
OnRealTimeTickDataDateChange.Invoke("realtimetickdatahandler", m_PreviousTickData.DataDate,
tickData.DataDate);
}
}
m_PreviousTickData = tickData; //set the prev tick data from the current
}
catch (Exception ex)
{
}
}
private TickDataUpdateType GetUpdateType(MarketTickData tickData)
{
TickDataUpdateType tickDataUpdateType = TickDataUpdateType.None;
if (tickData.Ask > 0 && tickData.Ask < 2000000)
{
tickDataUpdateType = TickDataUpdateType.Ask | TickDataUpdateType.AskQty;
}
if (tickData.Bid > 0 && tickData.Bid < 2000000)
{
tickDataUpdateType = tickDataUpdateType | TickDataUpdateType.Bid | TickDataUpdateType.BidQty;
}
if (tickData.SettlementPrice > 0 && tickData.SettlementPrice < 2000000)
{
tickDataUpdateType = tickDataUpdateType | TickDataUpdateType.SettlementPrice | TickDataUpdateType.SettlementQty;
}
return(tickDataUpdateType);
}
void m_TickDataHandler_OnRealTimeTickDataUpdate(string sender, MarketTickData tickData)
{
lock (m_lock)
{
m_TickDataHandler.PauseReceive();
if (tickData.Ask > 0 && tickData.Ask < 2147483648)
{
m_SimpleBarDataHandlers[BarDataType.Ask].Add(tickData.Timestamp, tickData.Ask, tickData.DataDateTime);
}
if (tickData.AskQty > 0 && tickData.AskQty < 2147483648)
{
m_SimpleBarDataHandlers[BarDataType.AskQty].Add(tickData.Timestamp, tickData.AskQty, tickData.DataDateTime);
}
if (tickData.Bid > 0 && tickData.Bid < 2147483648)
{
m_SimpleBarDataHandlers[BarDataType.Bid].Add(tickData.Timestamp, tickData.Bid, tickData.DataDateTime);
}
if (tickData.BidQty > 0 && tickData.BidQty < 2147483648)
{
m_SimpleBarDataHandlers[BarDataType.BidQty].Add(tickData.Timestamp, tickData.BidQty, tickData.DataDateTime);
}
if (tickData.SettlementPrice > 0 && tickData.SettlementPrice < 2147483648)
{
m_SimpleBarDataHandlers[BarDataType.SettlementPrice].Add(tickData.Timestamp,
tickData.SettlementPrice, tickData.DataDateTime);
}
if (tickData.SettlementQty > 0 && tickData.SettlementQty < 2147483648)
{
m_SimpleBarDataHandlers[BarDataType.SettlementQty].Add(tickData.Timestamp, tickData.SettlementQty, tickData.DataDateTime);
}
m_TickDataHandler.ResumeReceive();
}
}
private static void Trade3()
{
// Settings
BTCMarketsHelper.ProfitMargin = 0;
// Get number of Open Orders
OpenOrdersHistory = BTCMarketsHelper.OrderOpen(CURRENCY, INSTRUMENT, 10, "1");
if (OpenOrdersHistory.success && OpenOrdersHistory.orders != null)
{
if (OpenOrdersHistory.orders.Length > 1)
{
Console.WriteLine("Open orders are still active...");
}
else
{
// get ETH/BTC market data i.e. instrument/currency
Console.WriteLine($"Previous Ask Price: {lastETH_BTC}");
MarketTickData marketData = BTCMarketsHelper.GetMarketTick($"{INSTRUMENT}/{CURRENCY}");
Console.WriteLine($"Current Ask Price: {marketData.bestAsk}");
lastETH_BTC = marketData.bestAsk;
// get trading data
TradingData tradingData = TradingHelper.GetTradingData(marketData);
if (lastETH_BTC > 0) // ensure first round is skipped when there is no history
{
if (marketData.bestAsk > lastETH_BTC)
{
Console.WriteLine($"Previous Volume (BTC): {lastBTC_Volume}");
if (tradingData.BuyVolume > lastBTC_Volume)
{
Console.WriteLine("ETH has gone stronger. Sell ETH.");
}
}
else if (marketData.bestAsk < lastETH_BTC)
{
Console.WriteLine("BTC has gone stronger. Buy ETH.");
Console.WriteLine($"Previous Buy Volume (ETH): {lastETH_Volume}");
Console.WriteLine($"Current Buy volume ({marketData.instrument}): {tradingData.BuyVolume}");
}
}
Console.WriteLine($"Buy price ({marketData.currency}): {tradingData.BuyPrice}");
Console.WriteLine($"Sell volume ({marketData.instrument}): {tradingData.SellVolume}");
Console.WriteLine($"Sell price ({marketData.currency}): {tradingData.SellPrice}");
Console.WriteLine($"Spend total ({marketData.currency}): {tradingData.SpendTotal}");
/*
* // create orders
* CreateOrderData buyOrder = BTCMarketsHelper.CreateNewOrder(marketData.currency, marketData.instrument,
* (long)(tradingData.BuyPrice * ApplicationConstants.NUMERIC_MULTIPLIER),
* (int)(tradingData.BuyVolume * ApplicationConstants.NUMERIC_MULTIPLIER),
* "Bid", "Limit");
*
* if (buyOrder.success)
* {
* CreateOrderData sellOrder = BTCMarketsHelper.CreateNewOrder(marketData.currency, marketData.instrument,
* (long)(tradingData.SellPrice * ApplicationConstants.NUMERIC_MULTIPLIER),
* (int)(tradingData.SellVolume * ApplicationConstants.NUMERIC_MULTIPLIER),
* "Ask", "Limit");
*
* if (sellOrder.success)
* {
* // append csv line
* BotLogger.WriteLine($",{tradingData.BuyVolume.ToDecimalString(8)}, {marketData.instrument}, Balance (Unit 2), " +
* $"{tradingData.BuyPrice.ToDecimalString(8)}, {marketData.currency}, {tradingData.SpendTotal.ToDecimalString(8)}, {BTCMarketsHelper.ProfitMargin}%, " +
* $"{tradingData.SellVolume.ToDecimalString(8)}, {tradingData.SellPrice.ToDecimalString(8)}");
* }
* else
* {
* Console.WriteLine(sellOrder.errorMessage);
* }
* }
* else
* {
* Console.WriteLine(buyOrder.errorMessage);
* }
*/
}
}
else
{
Console.WriteLine(OpenOrdersHistory.errorMessage);
}
Console.WriteLine(CONSOLE_WAITING);
Console.WriteLine();
}
private static void Trade1()
{
// Settings
BTCMarketsHelper.ProfitMargin = 2;
// Get number of Open Orders
OpenOrdersHistory = BTCMarketsHelper.OrderOpen(CURRENCY, INSTRUMENT, 10, "1");
if (OpenOrdersHistory.success && OpenOrdersHistory.orders != null)
{
if (OpenOrdersHistory.orders.Length > 1)
{
Console.WriteLine("Open orders are still active...");
}
else
{
// get ETH/BTC market data i.e. instrument/currency
MarketTickData marketData = BTCMarketsHelper.GetMarketTick($"{INSTRUMENT}/{CURRENCY}");
// get trading data
TradingData tradingData = TradingHelper.GetTradingData(marketData, splitProfitMargin: true);
Console.WriteLine($"Buy volume ({marketData.instrument}): {tradingData.BuyVolume}");
Console.WriteLine($"Buy price ({marketData.currency}): {tradingData.BuyPrice}");
Console.WriteLine($"Sell volume ({marketData.instrument}): {tradingData.SellVolume}");
Console.WriteLine($"Sell price ({marketData.currency}): {tradingData.SellPrice}");
Console.WriteLine($"Spend total ({marketData.currency}): {tradingData.SpendTotal}");
// create orders
CreateOrderData buyOrder = BTCMarketsHelper.CreateNewOrder(marketData.currency, marketData.instrument,
(long)(tradingData.BuyPrice * ApplicationConstants.NUMERIC_MULTIPLIER),
(long)(tradingData.BuyVolume * ApplicationConstants.NUMERIC_MULTIPLIER),
"Bid", "Limit");
if (buyOrder.success)
{
System.Threading.Thread.Sleep(rnd.Next(1, 10) * 1000);
CreateOrderData sellOrder = BTCMarketsHelper.CreateNewOrder(marketData.currency, marketData.instrument,
(long)(tradingData.SellPrice * ApplicationConstants.NUMERIC_MULTIPLIER),
(long)(tradingData.SellVolume * ApplicationConstants.NUMERIC_MULTIPLIER),
"Ask", "Limit");
if (sellOrder.success)
{
// append csv line
BotLogger.WriteLine($",{tradingData.BuyVolume}, {marketData.instrument}, Balance (Unit 2), " +
$"{tradingData.BuyPrice}, {marketData.currency}, {tradingData.SpendTotal}, {BTCMarketsHelper.ProfitMargin}%, " +
$"{tradingData.SellVolume}, {tradingData.SellPrice}");
}
else
{
Console.WriteLine(sellOrder.errorMessage);
}
}
else
{
Console.WriteLine(buyOrder.errorMessage);
}
}
}
else
{
Console.WriteLine(OpenOrdersHistory.errorMessage);
}
Console.WriteLine(CONSOLE_WAITING);
Console.WriteLine();
}
void TickDataSubscriber_OnTickDataReceived(MarketTickData tickData)
{
RunReceive(tickData);
}
private static void OnTickDataUpdateReceived(int jobid, MarketTickData tickData, int barIndex)
{
m_JobStat.AddMarketTickData(barIndex, tickData);
}
public void AddMarketTickData(int barIndex, MarketTickData tickData)
{
m_tickDatas.Add(new Tuple <int, MarketTickData>(barIndex, tickData));
}
