public void OrderBook_StopToMarket(object sender, OrderEventArgs e)
{
foreach (Order curBuyOrder in e.BuyBook)
{
if (OrderBook.marketPrice > curBuyOrder.Price)
{
// Order temp = curBuyOrder;
FuturesOrder order = new FuturesOrder("MSFT", "Market", "B", curBuyOrder.Price, curBuyOrder.Quantity, "New");
curBuyOrder.Quantity = 0;
tempDomain.deleteOrder(curBuyOrder);
tempDomain.checkMargin(order);
tempDomain.SubmitOrder("MSFT", order);
Console.WriteLine("one buy stop becomes market. New Market order is ID " + order.OrderID + " order type " + order.OrderType + " buysell " + order.BuySell + " Price " + order.Price + " quantity " + order.Quantity + " action " + order.OrderAction);
}
}
foreach (Order curSellOrder in e.SellBook)
{
if (OrderBook.marketPrice < curSellOrder.Price)
{
Order temp = curSellOrder;
curSellOrder.Quantity = 0;
FuturesOrder order = new FuturesOrder("MSFT", "Market", "S", temp.Price, temp.Quantity, "New");
tempDomain.SubmitOrder("MSFT", order);
Console.WriteLine("one sell stop becomes market. New Market order is ID " + order.OrderID + " order type " + order.OrderType + " buysell " + order.BuySell + " Price " + order.Price + " quantity " + order.Quantity + " action " + order.OrderAction);
}
}
}
public void ReceiveAsyncCallback(IAsyncResult iAsyncResult)
{
// Thread.Sleep(100);
//ThreadPoolMessage("\nMessage is receiving");
// endRead
NetworkStream networkStreamRead = tcpClient.GetStream();
int length = networkStreamRead.EndRead(iAsyncResult);
//check message
if (length < 1)
{
tcpClient.GetStream().Close();
throw new Exception("Disconnection!");
}
//show received message
string message = Encoding.UTF8.GetString(byteMessage, 0, length);
FuturesOrder order1 = (FuturesOrder) new XmlObjectSerializer().Deserialize(message);
Console.WriteLine("Order received");
equityDomain.checkMargin(order1);
equityDomain.SubmitOrder("MSFT", order1 as Order);
//send back message
byte[] sendMessage = Encoding.UTF8.GetBytes(DateTime.Now + " From Server: Message is received!");
NetworkStream networkStreamWrite = tcpClient.GetStream();
networkStreamWrite.BeginWrite(sendMessage, 0, sendMessage.Length, new AsyncCallback(SendAsyncCallback), null);
}
public static FuturesOrder LoadFromXMLString(string xmlText)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(FuturesOrder));
StringReader stringReader = new StringReader(xmlText /* result is the value from the database */);
FuturesOrder deserializedEntity = (FuturesOrder)xmlSerializer.Deserialize(stringReader);
return(deserializedEntity as FuturesOrder);
}
private void MatchBuyLogic(OrderEventArgs e)
{
foreach (Order curOrder in e.SellBook)
{
if (e.Order.OrderType == "MARKET" && e.Order.Quantity > 0)
{
Console.WriteLine("Match found..Generate Market Order Trade..");
int quantity = Math.Min(e.Order.Quantity, curOrder.Quantity); //need to check this
curOrder.Quantity = curOrder.Quantity - quantity;
e.Order.Quantity = e.Order.Quantity - quantity;
Console.WriteLine(quantity.ToString() + " " + curOrder.Instrument.ToString() + " at " + curOrder.LimitPrice.ToString() + " order ID's " + curOrder.OrderID.ToString() + " & " + e.Order.OrderID.ToString());
// write executed orders to xml file
//records trade info and sends executed order info back to client
FuturesOrder executedOrder1 = (FuturesOrder)curOrder.Clone();//make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = quantity;
executedOrder1.executionPrice = curOrder.LimitPrice;
executedOrder1.ExecutionTimeStamp = DateTime.Now;
FuturesOrder executedOrder2 = (FuturesOrder)e.Order.Clone();//make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = quantity;
executedOrder2.executionPrice = curOrder.LimitPrice;
executedOrder2.ExecutionTimeStamp = DateTime.Now;
//send executed order back to client
ClearingHouseTest.UpdateMarginForExucutedOrder(executedOrder1); //used to update margin with actual execution price
ClearingHouseTest.UpdateMarginForExucutedOrder(executedOrder2); //used to update margin with actual execution price
ExecutedOrdersToSend.TcpClientTest.Connect(OMEHost.ToXML(executedOrder1));
ExecutedOrdersToSend.TcpClientTest.Connect(OMEHost.ToXML(executedOrder2));
}
else if (curOrder.LimitPrice <= e.Order.LimitPrice && e.Order.Quantity > 0)
{
Console.WriteLine("Match found..Generate Trade..");
int quantity = Math.Min(e.Order.Quantity, curOrder.Quantity);
curOrder.Quantity = curOrder.Quantity - e.Order.Quantity;
e.Order.Quantity = e.Order.Quantity - quantity;
Console.WriteLine(quantity.ToString() + " " + curOrder.Instrument.ToString() + " at " + curOrder.LimitPrice.ToString() + " order ID's " + curOrder.OrderID.ToString() + " & " + e.Order.OrderID.ToString());
//records trade info and sends executed order info back to client
FuturesOrder executedOrder1 = (FuturesOrder)curOrder.Clone();//make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = quantity;
executedOrder1.executionPrice = curOrder.LimitPrice;
executedOrder1.ExecutionTimeStamp = DateTime.Now;
FuturesOrder executedOrder2 = (FuturesOrder)e.Order.Clone();//make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = quantity;
executedOrder2.executionPrice = curOrder.LimitPrice;
executedOrder2.ExecutionTimeStamp = DateTime.Now;
ClearingHouseTest.UpdateMarginForExucutedOrder(executedOrder1); //used to update margin with actual execution price
ClearingHouseTest.UpdateMarginForExucutedOrder(executedOrder2); //used to update margin with actual execution price
//send executed order back to client
ExecutedOrdersToSend.TcpClientTest.Connect(OMEHost.ToXML(executedOrder1));
ExecutedOrdersToSend.TcpClientTest.Connect(OMEHost.ToXML(executedOrder2));
}
else
{
break;
}
}
}
public void EnQueue(object order1)
{
msgQueue.Enqueue(order1);
FuturesOrder order = (FuturesOrder)order1;
Console.WriteLine();
// Console.WriteLine("An order submitted: ID " + order.OrderID + " order type " + order.OrderType + " buysell " + order.BuySell + " Price " + order.Price + " quantity " + order.Quantity + " action " + order.OrderAction);
processSignaller.Set();
}
static void Main(string[] args)
{
//connect server
try
{
bool found = false;
FuturesOrder orders = PickOne(2, ref found);
Console.WriteLine(found);
TcpClient tcpClient;
tcpClient = new TcpClient("127.0.0.1", 500);
NetworkStream networkStream;
networkStream = tcpClient.GetStream();
byte[] sendMessage;
byte[] receiveMessage;
while (true)
{
Thread.Sleep(1000);
//here generate order
FuturesOrder order = newOrder();
countNum++;
string xml = new XmlObjectSerializer().Serialize(order).OuterXml;
sendMessage = Encoding.UTF8.GetBytes(xml);
networkStream.Write(sendMessage, 0, sendMessage.Length);
networkStream.Flush();
//receive message
receiveMessage = new byte[1024];
int count = networkStream.Read(receiveMessage, 0, 1024);
Console.WriteLine(Encoding.UTF8.GetString(receiveMessage));
}
// networkStream.Close();
// tcpClient.Close();
}
catch (Exception e)
{
Console.WriteLine("exception: " + e.ToString());
}
finally
{
}
Console.ReadKey();
}
static FuturesOrder PickOne(int traderID, ref bool found)
{
xmlDoc.Load("C:\\Users\\chuan\\Desktop\\CSC559\\Final Project\\exchange\\Exchange1.9\\server2\\bin\\Debug\\ClearingHouse.xml");
found = false;
XmlNodeList nodeList = xmlDoc.SelectSingleNode("ClearingHouse").ChildNodes;
FuturesOrder order = null;
foreach (XmlNode xn in nodeList) //遍历所有子节点
{
XmlElement xe = (XmlElement)xn; //将子节点类型转换为XmlElement类型
if (int.Parse(xe.GetAttribute("ID")) == traderID) //find trader
{
XmlNodeList nodeListOfOrder = xe.ChildNodes;
int count = nodeListOfOrder.Count;
if (count == 0)
{
return(order);
}
else
{
Random rnd = new Random();
int mIndex = rnd.Next(0, nodeListOfOrder.Count);
int num = 0;
foreach (XmlNode ordn in nodeListOfOrder)
{
if (num == mIndex)
{
found = true;
XmlElement ord = (XmlElement)ordn;
string instrument = ord.GetAttribute("Instrument");
long orderId = long.Parse(ord.GetAttribute("OrderID"));
string ordertype = ord.GetAttribute("OrderType");
string buysell = ord.GetAttribute("BuySell");
double price = double.Parse(ord.GetAttribute("Price"));
int quantity = int.Parse(ord.GetAttribute("Quantity"));
order = new FuturesOrder(instrument, ordertype, buysell, price, quantity, "None");
order.OrderID = orderId;
return(order);
}
num++;
}
}
}
}
return(order);
}
public void StopToMarket(object Order)
{
FuturesOrder order = (FuturesOrder)Order;
// OrderBook temp = new OrderBook();
Container container = ProcessContainers(bookRoot, order.Instrument, order, null);
container = ProcessContainers(container.ChildContainers, order.OrderType, order, container);
if (container.ChildContainers.Exists(order.BuySell.ToString()) == false)
{
LeafContainer buyContainer = new LeafContainer(this, "B", container);
LeafContainer sellContainer = new LeafContainer(this, "S", container);
container.ChildContainers["B"] = buyContainer;
container.ChildContainers["S"] = sellContainer;
}
LeafContainer leafContainer = container.ChildContainers[order.BuySell.ToString()] as LeafContainer;
leafContainer.ProcessStopOrder(order);
}
} // Process()
private void ProcessDataReceived()
{
try
{
if (sb.Length > 0)
{
bool bQuit = (String.Compare(sb.ToString(), "quit", true) == 0);
data = sb.ToString();
sb.Length = 0; // Clear buffer
Console.WriteLine("Text received from client:");
FuturesOrder newOrder = EquityMatchingEngine.OMEHost.LoadFromXMLString(data);
orderIDs += newOrder.OrderID.ToString() + ",";
Task.Factory.StartNew(() => domain.SubmitOrder(newOrder));
string response;
response = (" Order Received");
// Echo the data back to the client.
byte[] sendBytes = Encoding.ASCII.GetBytes(response.ToString());
networkStream.Write(sendBytes, 0, sendBytes.Length);
// Client stop processing
if (bQuit)
{
networkStream.Close();
ClientSocket.Close();
ContinueProcess = false;
}
}
}
catch (Exception)
{
networkStream.Close();
ClientSocket.Close();
ContinueProcess = false;
}
}
public void onOrderMatched(MatchedOrderArgs orderArgs, long id1)
{
lock (sync)
{
XmlNodeList nodeList = xmlDoc.SelectSingleNode("ClearingHouse").ChildNodes;//
long ID1 = id1 / 100000000;
foreach (XmlNode xn in nodeList)//遍历所有子节点
{
XmlElement xe = (XmlElement)xn;
if (long.Parse(xe.GetAttribute("ID")) == ID1)//find trader
{
int oriTotal = int.Parse(xe.GetAttribute("TotalOrder"));
int newTotal = oriTotal - orderArgs.Quantity;
if (newTotal < 0)
{
newTotal = 0;
}
xe.SetAttribute("TotalOrder", newTotal.ToString());
xe.SetAttribute("CurrentQuote", orderArgs.Quote.ToString());
double requiredMargin = newTotal * orderArgs.Quote * 0.02 * 0.9;
double marginAccount = double.Parse(xe.GetAttribute("MarginAccount"));
double bankAccount = double.Parse(xe.GetAttribute("BankAccount"));
if (marginAccount >= requiredMargin)
{
//change order info
XmlNodeList nodeListOfOrder = xe.ChildNodes;
foreach (XmlNode ordn in nodeListOfOrder)
{
XmlElement orde = (XmlElement)ordn;
if (orde.GetAttribute("OrderID") == id1.ToString())
{
// Console.WriteLine(orderArgs.ID1 + " orderArgs.ID1");
string oriQuantitiy = orde.GetAttribute("Quantity");
// Console.WriteLine(oriQuantitiy + " oriQuantitiy");
int newQuantity = int.Parse(oriQuantitiy) - orderArgs.Quantity;
orde.SetAttribute("Quantity", newQuantity.ToString());
if (newQuantity < 0)
{
Console.WriteLine("after matching, one order has quantity<0, may be caused by modifying one xml file by multithreads");
Console.WriteLine("orderId " + id1);
}
if (newQuantity == 0)
{
xe.RemoveChild(orde);
}
}
}
}
else if ((marginAccount + bankAccount) >= requiredMargin)
{
//put more into margin account
double amount = (requiredMargin - marginAccount);
marginAccount = marginAccount + amount;
bankAccount = bankAccount - amount;
xe.SetAttribute("MarginAccount", marginAccount.ToString());
xe.SetAttribute("BankAccount", bankAccount.ToString());
//change order info
XmlNodeList nodeListOfOrder = xe.ChildNodes;
foreach (XmlNode ordn in nodeListOfOrder)
{
XmlElement orde = (XmlElement)ordn;
if (orde.GetAttribute("OrderID") == id1.ToString())
{
string oriQuantitiy = orde.GetAttribute("Quantity");
int newQuantity = int.Parse(oriQuantitiy) - orderArgs.Quantity;
orde.SetAttribute("Quantity", newQuantity.ToString());
if (newQuantity < 0)
{
Console.WriteLine("after matching, one order has quantity<0, may be caused by modifying one xml file by multithreads");
}
if (newQuantity == 0)
{
xe.RemoveChild(orde);
}
}
}
}
else
{
// not have enough money;clear all
XmlNodeList nodeListOfOrder = xe.ChildNodes;
foreach (XmlNode ordn in nodeListOfOrder)
{
//Console.WriteLine("delete................");
XmlElement orde = (XmlElement)ordn;
string instrument = orde.GetAttribute("Instrument");
string orderType = orde.GetAttribute("OrderType");
string buySell = orde.GetAttribute("BuySell");
double price = double.Parse(orde.GetAttribute("Price"));
int quantity = int.Parse(orde.GetAttribute("Quantity"));
long orderID = long.Parse(orde.GetAttribute("OrderID"));
FuturesOrder order = new FuturesOrder(instrument, orderType, buySell, price, quantity, "Cancel");
order.OrderID = orderID;
SubmitOrder("MSFT", order);
insertIntoOrderHistory(order);
xe.RemoveChild(ordn);
}
xe.SetAttribute("TotalOrder", "0");
}
}
}
xmlDoc.Save("ClearingHouse.xml");
}
}
static void Main(string[] args)
{
// ManualResetEvent processSignaller = new ManualResetEvent(false);
BizDomain equityDomain;
equityDomain = new BizDomain("Equity Domain", new string[] { "MSFT", "BAC", "GE", "WFC" });
equityDomain.OrderBook.OrderPriority = new PriceTimePriority();
equityDomain.OrderBook.OrderPriorityForMarket = new TimePriorityForMarket();
EquityMatchingLogic equityMatchingLogic = new EquityMatchingLogic(equityDomain);
// HandleStop handleStop=new HandleStop(equityDomain);
// equityDomain.OrderBook.StopToMarketEvent += new OrderEventHandler(equityMatchingLogic.OrderBook_StopToMarket);
equityDomain.Start();
//test Market order
// equityDomain.SubmitOrder("MSFT", new FuturesOrder("MSFT", "Market", "B", 20, 3, "Trader1","new"));
// equityDomain.SubmitOrder("MSFT", new FuturesOrder("MSFT", "Market", "S", 16, 5, "Trader1","new"));
//test limit order
// equityDomain.SubmitOrder("MSFT", new FuturesOrder("MSFT", "Limit", "B", 25, 3, "Trader1","new"));
// equityDomain.SubmitOrder("MSFT", new FuturesOrder("MSFT", "Limit", "S", 10, 5, "Trader1","new"));
//test cancel order; orderID should be send by client
/*
* FuturesOrder OriOrder = new FuturesOrder("MSFT", "Limit", "B", 25, 3, "Trader1", "New");
* FuturesOrder testDelete = new FuturesOrder("MSFT", "Limit", "B", 25, 3, "Trader1", "Cancel");
* testDelete.OrderID = OriOrder.OrderID;
*
* equityDomain.SubmitOrder("MSFT", OriOrder);
* equityDomain.SubmitOrder("MSFT", testDelete);
*
* //test update order;orderID should be send by client
*
* FuturesOrder UOrder = new FuturesOrder("MSFT", "Limit", "B", 25, 3, "Trader1", "New");
* FuturesOrder testUpdate = new FuturesOrder("MSFT", "Limit", "B", 20, 5, "Trader1", "Update");
* testUpdate.OrderID = UOrder.OrderID;
* equityDomain.SubmitOrder("MSFT", UOrder);
* equityDomain.SubmitOrder("MSFT", testUpdate);
*
* FuturesOrder UOrder = new FuturesOrder("MSFT", "Market", "B", 25, 3, "Trader1", "New");
* FuturesOrder testUpdate = new FuturesOrder("MSFT", "Market", "B", 20, 5, "Trader1", "Update");
* testUpdate.OrderID = UOrder.OrderID;
* equityDomain.SubmitOrder("MSFT", UOrder);
* equityDomain.SubmitOrder("MSFT", testUpdate);
*/
FuturesOrder SOrder = new FuturesOrder("MSFT", "Stop", "S", 15, 3, "Trader1", "New");
equityDomain.SubmitOrder("MSFT", SOrder);
equityDomain.SubmitOrder("MSFT", new FuturesOrder("MSFT", "Limit", "S", 10, 5, "Trader1", "New"));
equityDomain.SubmitOrder("MSFT", new FuturesOrder("MSFT", "Limit", "B", 25, 3, "Trader1", "New"));
Console.ReadLine();
return;
}
public void Run()
{
const string settle = "usdt";
const string contract = "BTC_USDT";
Configuration config = new Configuration
{
BasePath = _runConfig.HostUsed,
ApiV4Key = _runConfig.ApiKey,
ApiV4Secret = _runConfig.ApiSecret,
};
FuturesApi futuresApi = new FuturesApi(config);
// update position leverage
const string leverage = "3";
futuresApi.UpdatePositionLeverage(settle, contract, leverage);
// retrieve position information
long positionSize = 0L;
try
{
Position position = futuresApi.GetPosition(settle, contract);
positionSize = position.Size;
}
catch (GateApiException e)
{
// ignore no position error
if (!"POSITION_NOT_FOUND".Equals(e.ErrorLabel))
{
throw;
}
}
// set order size
Contract futuresContract = futuresApi.GetFuturesContract(settle, contract);
long orderSize = 10L;
if (futuresContract.OrderSizeMin > orderSize)
{
orderSize = futuresContract.OrderSizeMin;
}
if (positionSize < 0)
{
// if short, set size to negative
orderSize = -orderSize;
}
// example to update risk limit
string riskLimit =
(Convert.ToDecimal(futuresContract.RiskLimitBase) + Convert.ToDecimal(futuresContract.RiskLimitStep))
.ToString(CultureInfo.InvariantCulture);
futuresApi.UpdatePositionRiskLimit(settle, contract, riskLimit);
// retrieve last price to calculate margin needed
List <FuturesTicker> tickers = futuresApi.ListFuturesTickers(settle, contract);
Debug.Assert(tickers.Count == 1);
string lastPrice = tickers[0].Last;
Console.WriteLine("last price of contract {0}: {1}", contract, lastPrice);
decimal margin = decimal.Round(orderSize * Convert.ToDecimal(lastPrice) *
Convert.ToDecimal(futuresContract.QuantoMultiplier) / Convert.ToDecimal(leverage) * 1.1m, 8,
MidpointRounding.AwayFromZero);
Console.WriteLine("needs margin amount: " + margin.ToString(CultureInfo.InvariantCulture));
// if balance not enough, transfer from spot account
string available = "0";
try
{
available = futuresApi.ListFuturesAccounts(settle).Available;
}
catch (GateApiException e)
{
if (!"USER_NOT_FOUND".Equals(e.ErrorLabel))
{
throw;
}
}
Console.WriteLine("Futures account available: {0} {1}", available, settle.ToUpper());
if (Convert.ToDecimal(available).CompareTo(margin) < 0)
{
if (_runConfig.UseTestNet)
{
Console.Error.WriteLine("TestNet account balance not enough, make a transferal on web");
return;
}
Transfer transfer = new Transfer(currency: settle.ToUpper(), amount: margin.ToString(CultureInfo.InvariantCulture))
{
From = Transfer.FromEnum.Spot,
To = Transfer.ToEnum.Futures,
};
WalletApi walletApi = new WalletApi(config);
walletApi.Transfer(transfer);
}
// example to cancel all open orders in contract
futuresApi.CancelFuturesOrders(settle, contract, "");
FuturesOrder futuresOrder = new FuturesOrder(contract)
{
Size = orderSize,
Price = "0",
Tif = FuturesOrder.TifEnum.Ioc,
};
FuturesOrder orderResponse;
try
{
orderResponse = futuresApi.CreateFuturesOrder(settle, futuresOrder);
}
catch (GateApiException e)
{
Console.Error.WriteLine(e);
return;
}
Console.WriteLine("Order {0} created with status {1}", orderResponse.Id, orderResponse.Status);
if (FuturesOrder.StatusEnum.Open.Equals(orderResponse.Status))
{
FuturesOrder order = futuresApi.GetFuturesOrder(settle, orderResponse.Id.ToString());
Console.WriteLine("Order {0} status {1}, total size {2}, left {3}", order.Id, order.Status, order.Size,
order.Left);
futuresApi.CancelFuturesOrder(settle, order.Id.ToString());
Console.WriteLine("order {0} cancelled", order.Id);
}
else
{
List <MyFuturesTrade> orderTrades = futuresApi.GetMyTrades(settle, contract, orderResponse.Id);
Debug.Assert(orderTrades.Count > 0);
long tradeSize = 0L;
foreach (MyFuturesTrade t in orderTrades)
{
Debug.Assert(t.OrderId != null && t.OrderId.Equals(orderResponse.Id.ToString()));
tradeSize += t.Size;
Console.WriteLine("order {0} filled size {1} with price {2}", t.OrderId, t.Size, t.Price);
}
Debug.Assert(tradeSize == orderSize);
// example to update position margin
futuresApi.UpdatePositionMargin(settle, contract, "0.01");
}
}
static void Main(string[] args)
{
try
{
// ThreadPool.SetMaxThreads(1000, 1000);
BizDomain equityDomain;
equityDomain = new BizDomain("Equity Domain", new string[] { "MSFT", "BAC", "GE", "WFC" });// for us, instument means maturity?
equityDomain.OrderBook.OrderPriority = new PriceTimePriority();
equityDomain.OrderBook.OrderPriorityForMarket = new TimePriorityForMarket();
EquityMatchingLogic equityMatchingLogic = new EquityMatchingLogic(equityDomain);
equityDomain.Start();
equityDomain.Start2();
//test
bool validOrder;
/*
* FuturesOrder MarketOrder = new FuturesOrder("MSFT", "Market", "B", 30.0, 50, "New");
* validOrder = equityDomain.checkMargin(MarketOrder);
*
* if(validOrder)
* equityDomain.SubmitOrder("MSFT", MarketOrder);
*
* FuturesOrder MarketOrder2 = new FuturesOrder("MSFT", "Market", "S", 25.0, 30, "New");
* validOrder = equityDomain.checkMargin(MarketOrder2);
*
* if (validOrder)
* equityDomain.SubmitOrder("MSFT", MarketOrder2);
*/
/*
* FuturesOrder LimitOrder = new FuturesOrder("MSFT", "Limit", "B", 22.0, 60, "New");
* validOrder = equityDomain.checkMargin(LimitOrder);
* //Console.WriteLine("order could be submitted, true or false: " + validOrder);
* if (validOrder)
* equityDomain.SubmitOrder("MSFT", LimitOrder);
*
* FuturesOrder LimitOrder2 = new FuturesOrder("MSFT", "Limit", "S", 19.0, 60, "New");
* validOrder = equityDomain.checkMargin(LimitOrder2);
* //Console.WriteLine("order could be submitted, true or false: " + validOrder);
* if (validOrder)
* equityDomain.SubmitOrder("MSFT", LimitOrder2);
*
*/
/*
* FuturesOrder StopOrder = new FuturesOrder("MSFT", "Stop", "B", 25, 60, "New");
* validOrder = equityDomain.checkMargin(StopOrder);
* // Console.WriteLine("order could be submitted, true or false: " + validOrder);
* if (validOrder)
* equityDomain.SubmitOrder("MSFT", StopOrder);
*
* FuturesOrder LimitOrder3 = new FuturesOrder("MSFT", "Limit", "B", 26.0, 60, "New");
* validOrder = equityDomain.checkMargin(LimitOrder3);
* //Console.WriteLine("order could be submitted, true or false: " + validOrder);
* if (validOrder)
* equityDomain.SubmitOrder("MSFT", LimitOrder3);
*
* FuturesOrder LimitOrder4 = new FuturesOrder("MSFT", "Limit", "S", 26.0, 60, "New");
* validOrder = equityDomain.checkMargin(LimitOrder4);
* //Console.WriteLine("order could be submitted, true or false: " + validOrder);
* if (validOrder)
* equityDomain.SubmitOrder("MSFT", LimitOrder4);
*/
/*
* //update order
* Console.WriteLine("Update order");
*
* FuturesOrder LimitOrder4 = new FuturesOrder("MSFT", "Limit", "S", 26.0, 60, "New");
* validOrder = equityDomain.checkMargin(LimitOrder4);
* if (validOrder)
* equityDomain.SubmitOrder("MSFT", LimitOrder4);
*
* FuturesOrder UpdateOrder = new FuturesOrder("MSFT", "Limit", "S", 2, 2, "Update");
* UpdateOrder.OrderID = LimitOrder4.OrderID;
* validOrder = equityDomain.checkMargin(UpdateOrder);
*
* equityDomain.SubmitOrder("MSFT", UpdateOrder);
*
*
*
* //Cancel order
* Console.WriteLine("Cancel order");
* FuturesOrder CancelOrder = new FuturesOrder("MSFT", "Limit", "S", 1, 1, "Cancel");
* CancelOrder.OrderID = UpdateOrder.OrderID;
* validOrder = equityDomain.checkMargin(CancelOrder);
* equityDomain.SubmitOrder("MSFT", CancelOrder);
*
*/
/*
* //if update order lead to lack of margin; update order rejected
* FuturesOrder LimitOrder = new FuturesOrder("MSFT", "Limit", "B", 22.0, 60, "New");
* LimitOrder.OrderID = 310000000;
* validOrder = equityDomain.checkMargin(LimitOrder);
* Console.WriteLine("order info ID " + LimitOrder.OrderID + " order action " + LimitOrder.OrderAction);
* Console.WriteLine("order could be submitted, true or false: " + validOrder);
* if (validOrder)
* equityDomain.SubmitOrder("MSFT", LimitOrder);
*
* FuturesOrder LimitOrder2 = new FuturesOrder("MSFT", "Limit", "B", 19.0, 99, "Update");
* LimitOrder2.OrderID = 310000000;
* validOrder = equityDomain.checkMargin(LimitOrder2);
* Console.WriteLine("order info ID " + LimitOrder2.OrderID+" order action "+LimitOrder2.OrderAction);
* Console.WriteLine("update order could be submitted, true or false: " + validOrder);
* if (validOrder)
* equityDomain.SubmitOrder("MSFT", LimitOrder2);
*/
//if quote updated and margin is not enough, clear all position.
FuturesOrder LimitOrder = new FuturesOrder("MSFT", "Limit", "B", 500, 50, "New");
LimitOrder.OrderID = 310000000;
validOrder = equityDomain.checkMargin(LimitOrder);
Console.WriteLine("order info ID " + LimitOrder.OrderID + " order action " + LimitOrder.OrderAction);
Console.WriteLine("order could be submitted, true or false: " + validOrder);
if (validOrder)
{
equityDomain.SubmitOrder("MSFT", LimitOrder);
}
FuturesOrder LimitOrder4 = new FuturesOrder("MSFT", "Limit", "S", 19.5, 10, "New");
LimitOrder4.OrderID = 310000001;
validOrder = equityDomain.checkMargin(LimitOrder4);
Console.WriteLine("order info ID " + LimitOrder4.OrderID + " order action " + LimitOrder4.OrderAction);
Console.WriteLine("update order could be submitted, true or false: " + validOrder);
if (validOrder)
{
equityDomain.SubmitOrder("MSFT", LimitOrder4);
}
//host: 127.0.0.1
IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
TcpListener tcpListener = new TcpListener(ipAddress, 500);
tcpListener.Start();
while (true)
{
//chatClient listen to client
ChatClient chatClient = new ChatClient(tcpListener.AcceptTcpClient(), equityDomain);
}
}
catch (Exception e)
{
Console.WriteLine("exception: " + e.ToString());
}
finally {
}
}
static FuturesOrder newOrder()
{
string OrderAction = generateOrder.generateOrderAction();
string instrument;
string buySell;
double price;
int quantity;
string orderType;
FuturesOrder newOrder = null;
bool generateSucessful = false;
while (generateSucessful == false)
{
if (OrderAction.Equals("New"))
{
//new order
instrument = generateOrder.generateInstument();
buySell = generateOrder.generateBuySell();
price = generateOrder.generatePrice();
quantity = generateOrder.generateQuantity();
orderType = generateOrder.generateOrderType();
newOrder = new FuturesOrder(instrument, orderType, buySell, price, quantity, OrderAction);
generateSucessful = true;
}
else if (OrderAction.Equals("Update"))
{
if (currentOrders.Count == 0 || countNum < 60)
{
OrderAction = "New";
}
else
{
Random rnd = new Random();
int mIndex = rnd.Next(0, currentOrders.Count);
bool found = false;
newOrder = PickOne(2, ref found);
if (found == false)
{
OrderAction = "New";
}
else
{
newOrder.OrderAction = "Update";
newOrder.Quantity = newOrder.Quantity + 1;//what is the action of update..here just add 1 quantity
newOrder.Price = generateOrder.generatePrice();
newOrder.TimeStamp = DateTime.Now;
generateSucessful = true;
}
}
}
else
{
//choose one from current hold order to cancel
if (currentOrders.Count == 0 || countNum < 60)
{
OrderAction = "New";
}
else
{
Random rnd = new Random();
int mIndex = rnd.Next(0, currentOrders.Count);
bool found = false;
newOrder = PickOne(2, ref found);
if (found == false)
{
OrderAction = "New";
}
else
{
newOrder.OrderAction = "Cancel";
generateSucessful = true;
}
}
}
}
return(newOrder);
}
private void MatchOpen(OrderEventArgs e)
{
bool ordersLeft = true;
double BuyQuantity = 0;
double SellQuantity = 0;
ArrayList matchedLimitOrders = new ArrayList();
ArrayList matchedMarketOrders = new ArrayList();
e.BuyBook.Reset();
e.SellBook.Reset();
e.BuyBook.MoveNext();
e.SellBook.MoveNext();
Order BuyOrder = e.BuyBook.Current as Order;
Order SellOrder = e.SellBook.Current as Order;
int quantityMatched;
while (true) //need to pull the orders off of the datastore
{
if (SellOrder.LimitPrice < BuyOrder.LimitPrice)
{
if (BuyOrder.Quantity < SellOrder.Quantity)
{
quantityMatched = BuyOrder.Quantity;
BuyQuantity += BuyOrder.Quantity;
BuyOrder.Quantity = 0;
FuturesOrder executedOrder1 = (FuturesOrder)BuyOrder.Clone();
executedOrder1.ExecutionQuantity = quantityMatched;
//ExecutedOrders executedOrder1 = new ExecutedOrders(BuyOrder, quantityMatched, 0);
//BuyOrder.ExecutionQuantity = quantityMatched;
matchedLimitOrders.Add(executedOrder1);
SellOrder.Quantity = SellOrder.Quantity - quantityMatched;
FuturesOrder executedOrder2 = (FuturesOrder)SellOrder.Clone();
executedOrder1.ExecutionQuantity = quantityMatched;
//ExecutedOrders executedOrder2 = new ExecutedOrders(SellOrder, quantityMatched, 0);
matchedLimitOrders.Add(executedOrder2);
if (ordersLeft = e.BuyBook.MoveNext() == false)
{
break;
}
BuyOrder = e.BuyBook.Current as Order;
}
else
{
quantityMatched = SellOrder.Quantity;
SellQuantity += SellOrder.Quantity;
SellOrder.Quantity = 0;
BuyOrder.Quantity = BuyOrder.Quantity - quantityMatched;
FuturesOrder executedOrder1 = (FuturesOrder)BuyOrder.Clone(); //make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = quantityMatched;
FuturesOrder executedOrder2 = (FuturesOrder)SellOrder.Clone();
executedOrder1.ExecutionQuantity = quantityMatched;
matchedLimitOrders.Add(executedOrder1);
//SellOrder.ExecutionQuantity = quantityMatched;
matchedLimitOrders.Add(executedOrder2);
if (e.SellBook.MoveNext() == false)
{
break;
}
SellOrder = e.SellBook.Current as Order;
}
}
else
{
break;
}
}
double openPrice = Math.Round((SellOrder.LimitPrice + BuyOrder.LimitPrice) / 2.0, 2);
e.BuyBook.ResetMktOrder();
e.SellBook.ResetMktOrder();
ordersLeft = true;
ordersLeft = e.BuyBook.MoveNextMktOrder();
if (ordersLeft == false)
{
e.SellBook.MoveNextMktOrder();
Task.Factory.StartNew(() => e.SellBook.ProcessOrder(e.SellBook.CurrentMktOrder as Order));
while (e.SellBook.MoveNextMktOrder())
{
Task.Factory.StartNew(() => e.SellBook.ProcessOrder(e.SellBook.CurrentMktOrder as Order));
}
LeafContainer.openPriceFound.Set();
Task.Factory.StartNew(() => processMatchedLimitOrders(matchedLimitOrders, openPrice));
return;
}
ordersLeft = e.SellBook.MoveNextMktOrder();
if (ordersLeft == false)
{
e.BuyBook.MoveNextMktOrder();
Task.Factory.StartNew(() => e.BuyBook.ProcessOrder(e.BuyBook.CurrentMktOrder as Order));
while (e.BuyBook.MoveNextMktOrder())
{
Task.Factory.StartNew(() => e.BuyBook.ProcessOrder(e.BuyBook.CurrentMktOrder as Order));
}
LeafContainer.openPriceFound.Set();
Task.Factory.StartNew(() => processMatchedLimitOrders(matchedLimitOrders, openPrice));
return;
}
Order MktBuyOrder = e.BuyBook.CurrentMktOrder as Order;
Order MktSellOrder = e.SellBook.CurrentMktOrder as Order;
int ordersMatched;
while (true)
{
if (MktBuyOrder.Quantity > MktSellOrder.Quantity)
{
ordersMatched = MktSellOrder.Quantity;
MktSellOrder.Quantity = 0;
//ExecutedOrders executedOrder1 = new ExecutedOrders(MktSellOrder, ordersMatched, openPrice);
MktBuyOrder.Quantity = MktBuyOrder.Quantity - ordersMatched;
FuturesOrder executedOrder1 = (FuturesOrder)MktSellOrder.Clone(); //make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = ordersMatched;
FuturesOrder executedOrder2 = (FuturesOrder)MktBuyOrder.Clone(); //make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = ordersMatched;
matchedMarketOrders.Add(executedOrder1);
matchedMarketOrders.Add(executedOrder2);
//ExecutedOrders executedOrder2 = new ExecutedOrders(MktBuyOrder, ordersMatched, openPrice);
//send executed order back
if (e.SellBook.MoveNextMktOrder() == false)
{
//do something with remaining Market Sell orders
LeafContainer.openPriceFound.Set();
Task.Factory.StartNew(() => e.BuyBook.ProcessOrder(MktBuyOrder));
while (e.BuyBook.MoveNextMktOrder())
{
e.BuyBook.ProcessOrder(e.BuyBook.CurrentMktOrder as FuturesOrder);
}
break;
}
}
else //(MktBuyOrder.Quantity < MktSellOrder.Quantity)
{
ordersMatched = MktBuyOrder.Quantity;
MktBuyOrder.Quantity = 0;
//ExecutedOrders executedOrder2 = new ExecutedOrders((e.SellBook.CurrentMktOrder as Order), ordersMatched, openPrice);
MktSellOrder.Quantity = MktSellOrder.Quantity - ordersMatched;
FuturesOrder executedOrder1 = (FuturesOrder)MktSellOrder.Clone(); //make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = ordersMatched;
FuturesOrder executedOrder2 = (FuturesOrder)MktBuyOrder.Clone(); //make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = ordersMatched;
matchedMarketOrders.Add(executedOrder1);
matchedMarketOrders.Add(executedOrder2);
//ExecutedOrders executedOrder1 = new ExecutedOrders(e.Order, ordersMatched, openPrice);
if (e.BuyBook.MoveNextMktOrder() == false)
{
//do something with remaining Market Buy orders
LeafContainer.openPriceFound.Set();
Task.Factory.StartNew(() => e.SellBook.ProcessOrder(MktSellOrder));
while (e.SellBook.MoveNextMktOrder())
{
e.SellBook.ProcessOrder(e.SellBook.CurrentMktOrder as FuturesOrder);
}
break;
}
}
}
LeafContainer.openPriceFound.Set();
Task.Factory.StartNew(() => processMatchedLimitOrders(matchedLimitOrders, openPrice, matchedMarketOrders));
}
