private void InstanceOnMarketDataUpdate(ExchangeBase exchangeBase)
{
if (txtBidPx.InvokeRequired)
{
txtBidPx.Invoke(new EventHandler((sender, args) => UpdateGui(exchangeBase)));
}
}
public SentimentViewModel(ExchangeBase exchangeBase, TradesViewModel tradesViewModel)
: base(exchangeBase)
{
TradesViewModel = tradesViewModel;
TradesViewModel.UpdateEvent += TradesViewModelOnUpdateEvent;
}
public PairManageViewModel(ExchangeBase exchangeBase)
: base(exchangeBase)
{
foreach (var supportedPair in Exchange.PairManager.SupportedPairs.Values)
{
Pairs.Add(PairViewModel.FromPair(supportedPair));
}
SelectedPair = Pairs.FirstOrDefault();
}
public static TradesEntryViewModel FromModel(ExchangeBase exchangeBase, TradesEntryModel model)
{
var vm = new TradesEntryViewModel(exchangeBase)
{
Price = model.Price,
Amount = model.Amount,
Side = model.Side,
Timestamp = model.Timestamp,
Info = model.Info,
Type = model.Type
};
return(vm);
}
private void UpdateGui(ExchangeBase exchangeBase)
{
try
{
txtBidSz.Text = exchangeBase.MarketData.BidSz.ToString();
txtBidPx.Text = exchangeBase.MarketData.Bid.ToString();
txtAskPx.Text = exchangeBase.MarketData.Ask.ToString();
txtAskSz.Text = exchangeBase.MarketData.AskSz.ToString();
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
public static OrderViewModel Create(ExchangeBase exchange, OpenOrderEntryModel model)
{
return(new OrderViewModel(exchange)
{
OrderId = model.OrderId,
Pair = exchange.PairManager.GetPair(model.Symbol),
ExchangeName = model.ExchangeString,
Price = model.Price,
AvgerageExecutionPrice = model.AverageExecutionPrice,
Type = model.Type,
DateTime = model.DateTime,
Status = model.OrderStatus,
ExecutedAmount = model.ExecutedAmount,
RemainingAmount = model.RemainingAmount,
OriginalAmount = model.OriginalAmount
});
}
private void ProcessExchangeUpdate(object state)
{
while (true)
{
if (_exchangeUpdateQueue.Count == 0)
{
Thread.Sleep(2000);
}
ExchangeBase exchangeBase = null;
if (_exchangeUpdateQueue.TryDequeue(out exchangeBase))
{
//TODO: pubish event back to main form...
MarketDataUpdate(exchangeBase);
LastExchangeMarketData[exchangeBase.Exchange] = exchangeBase.MarketData;
}
}
}
public ExchangeViewModel(MainViewModel mainViewModel, ExchangeBase exchangeBase)
: base(exchangeBase)
{
Pairs = new PairManageViewModel(exchangeBase);
this.MainViewModel = mainViewModel;
this.Header = Exchange.Name;
//this.Foreground = Brushes.DodgerBlue;
MainViewModel.TimerSeconds.Tick += TimerSecondsOnTick;
Orders = new UserOrdersViewModel(Exchange);
Ticker = new TickerViewModel(Exchange);
OrderBook = new OrderBookViewModel(Exchange);
Trades = new TradesViewModel(MainViewModel, this, Exchange);
Balance = new BalanceViewModel(Exchange);
NewBuyOrder = new NewOrderViewModel(Exchange)
{
Side = OrderSide.Buy
};
NewSellOrder = new NewOrderViewModel(Exchange)
{
Side = OrderSide.Sell
};
if (!DesignerProperties.GetIsInDesignMode(new DependencyObject()))
{
UpdatePair();
//Exchange.ExchangeManager.Settings.
MainViewModel.SettingsService.SettingsLoaded += SettingsServiceOnSettingsLoaded;
Pairs.PairChanged += PairsOnPairChanged;
OrderBook.Ticker.LastTradeClickEvent += TickerOnLastTradeClickEvent;
OrderBook.SelectedAskChanged += OrderBookOnSelectedAskChanged;
OrderBook.SelectedBidChanged += OrderBookOnSelectedBidChanged;
Balance.SelectedBalanceChanged += BalanceOnSelectedBalanceChanged;
CreateTimer();
UpdateViewModels();
RegisterUpdates();
Ticker.Dispatched += TickerOnDispatched;
}
}
private void BwOnDoWork(object sender, DoWorkEventArgs doWorkEventArgs)
{
var btcExchangeEnum = doWorkEventArgs.Argument is BtcInfo.ExchangeEnum
? (BtcInfo.ExchangeEnum)doWorkEventArgs.Argument
: 0;
while (true)
{
try
{
lock (_lock)
{
ExchangeBase exchangeConnectionBase = null;
switch (btcExchangeEnum)
{
case BtcInfo.ExchangeEnum.BITFINEX:
exchangeConnectionBase = _exchanges[BtcInfo.ExchangeEnum.BITFINEX];
var bfExchange = exchangeConnectionBase as BitfinexExchange;
if (bfExchange != null)
{
bfExchange.ProcessMarketDataUpdate(PairType);
}
break;
}
if (exchangeConnectionBase != null)
{
exchangeConnectionBase.SetBtcMarketData(PairType);
_exchangeUpdateQueue.Enqueue(exchangeConnectionBase);
}
}
}
catch (Exception ex)
{
Logger.LogException(ex);
}
finally
{
Thread.Sleep(10000);
}
}
}
public void Start(string symbol)
{
MyMarketData = new MarketData(symbol);
ExchangeOKEX okexExchange = new ExchangeOKEX();
ExchangeBinance binanceExchange = new ExchangeBinance();
while (!m_marketMaker.Stop())
{
ExchangeBase exchange = m_marketMaker.GetExchange();
QuoteMgr quoteMgr = m_marketMaker.GetQuoteMgr();
AutoResetEvent quoteEventObj = quoteMgr.GetQuoteEventObject();
//Get reference price
MarketData okexMarketData = new MarketData(symbol);
okexExchange.UpdateMarketData(okexMarketData);
MarketData binanceMarketData = new MarketData(symbol);
binanceExchange.UpdateMarketData(binanceMarketData);
if (okexMarketData.DepthData.Mid > 0 && binanceMarketData.DepthData.Mid > 0)
{
//calculate fair value and market state
double avgMidPrice = (okexMarketData.DepthData.Mid + binanceMarketData.DepthData.Mid) / 2;
MyMarketData.FairValue = avgMidPrice;
if (Math.Abs(okexMarketData.DepthData.Mid / binanceMarketData.DepthData.Mid - 1) >= 0.01)
{
MyMarketData.IsNormal = false;
}
else
{
MyMarketData.IsNormal = true;
}
//Get current price
exchange.UpdateMarketData(MyMarketData);
//If not mock trade. Execute anti-arbitrage check
if (exchange.GetType() != typeof(ExchangeMock))
{
}
MyMarketData.DepthData.UpdateTime = DateTime.Now;
quoteEventObj.Set();
}
Thread.Sleep(50);
}
}
public async Task ProcessTask(OrdersTask task, ExchangeBase exchange)
{
if (task == null)
{
throw new ArgumentNullException("task");
}
if (exchange == null)
{
throw new ArgumentNullException("exchange");
}
string buyOrder = await exchange.PlaceOrderAsync(task.Currency, OrderType.Buy, task.BuyTask.Amount, task.BuyTask.Price);
var sellOrders = new List <string>(task.SellTasks.Count);
foreach (var sellTask in task.SellTasks)
{
var sellOrder = await exchange.PlaceLimitStopLossOrderAsync(task.Currency, OrderType.Sell, sellTask.Amount, sellTask.Price, task.StopLoss);
sellOrders.Add(sellOrder);
}
}
public OrderStatus(ExchangeBase exchange)
: base(exchange)
{
RequestUri = "/v1/order/status";
}
public NewOrderViewModel(ExchangeBase exchangeBase)
: base(exchangeBase)
{
LoadOrderTypes();
}
public CancelOrderRequest(ExchangeBase exchange)
: base(exchange)
{
RequestUri = "/0/private/CancelOrder";
}
public OrderViewModel(ExchangeBase exchangeBase)
: base(exchangeBase)
{
}
public void AddExchange(ExchangeBase exchangeBase)
{
Exchanges.Add(exchangeBase);
LoadedExchanges.Add(exchangeBase.GetType().FullName);
}
public Balance(ExchangeBase exchange)
: base(exchange)
{
RequestUri = "/v1/balances";
}
public Orders(ExchangeBase exchange)
: base(exchange)
{
RequestUri = "/v1/orders";
}
public OpenOrdersRequest(ExchangeBase exchange)
: base(exchange)
{
RequestUri = "/0/private/OpenOrders";
}
public TradesEntryViewModel(ExchangeBase exchangeBase)
: base(exchangeBase)
{
}
public BalanceViewModel(ExchangeBase exchangeBase)
: base(exchangeBase)
{
// Items.Add(new BalanceEntryViewModel { Available = 50000, Currency = CurrencyBase.USD, Type = "Exchange" });
}
public OrderBookViewModel(ExchangeBase exchangeBase)
: base(exchangeBase)
{
Ticker = new TickerViewModel(exchangeBase);
Update();
}
public CreateOrderEventArgs(ExchangeBase exchange, CreateOrderModel model)
{
_exchange = exchange;
_model = model;
}
public TickerViewModel(ExchangeBase exchangeBase)
: base(exchangeBase)
{
Update();
}
public TradesViewModel(MainViewModel mainViewModel, ExchangeViewModelBase parent, ExchangeBase exchangeBase)
: base(exchangeBase)
{
MainViewModel = mainViewModel;
SentimentViewModel = new SentimentViewModel(exchangeBase, this);
Parent = parent;
MainViewModel.TimerSeconds.Tick += TimerSecondsOnTick;
_updateController.Register("Trades", Update, 12, false, true);
Update();
}
public CreateOrderRequest(ExchangeBase exchange)
: base(exchange)
{
RequestUri = "/v1/order/new";
}
public OrderCancel(ExchangeBase exchange)
: base(exchange)
{
RequestUri = "/v1/order/cancel";
}
public UserOrdersViewModel(ExchangeBase exchangeBase)
: base(exchangeBase)
{
}
public CreateOrderRequest(ExchangeBase exchange)
: base(exchange)
{
RequestUri = "/0/private/AddOrder";
}
protected AuthenticatedRequest(ExchangeBase exchange)
{
this.Exchange = exchange;
}
