public static List <TickerCollection> GetItems()
{
List <TickerCollection> arbitrageList = new List <TickerCollection>();
List <List <Ticker> > markets = GetMarketsList();
foreach (Ticker ticker in markets.First())
{
TickerCollection info = new TickerCollection();
info.BaseCurrency = ticker.BaseCurrency;
info.MarketCurrency = ticker.MarketCurrency;
info.Add(ticker);
for (int i = 1; i < markets.Count; i++)
{
Ticker tt = markets[i].FirstOrDefault((t) => t.BaseCurrency == ticker.BaseCurrency && t.MarketCurrency == ticker.MarketCurrency);
if (tt == null)
{
continue;
}
info.Add(tt);
}
if (info.Count < 2)
{
continue;
}
info.UsdTicker = markets.First().FirstOrDefault((t) => t.MarketCurrency == info.BaseCurrency && t.BaseCurrency == "USDT");
arbitrageList.Add(info);
}
foreach (TickerCollection coll in arbitrageList)
{
for (int i = 0; i < coll.Count; i++)
{
coll.Tickers[i].UpdateMode = TickerUpdateMode.Arbitrage;
}
}
return(arbitrageList);
}
protected void OnThreadUpdate(object state)
{
try {
if (Ticker != null && !Ticker.Exchange.SupportWebSocket(WebSocketType.Tickers))
{
Ticker.UpdateTicker();
}
if (Ticker != null && !Ticker.Exchange.SupportWebSocket(WebSocketType.Ticker))
{
Ticker.UpdateOrderBook();
}
if (Ticker != null && !Ticker.Exchange.SupportWebSocket(WebSocketType.Ticker))
{
Ticker.UpdateTrades();
}
if (Ticker != null)
{
Ticker.UpdateOpenedOrders();
}
if (Ticker != null)
{
Ticker.UpdateTrailings();
}
if (Ticker != null)
{
Ticker.Time = DateTime.UtcNow;
}
if (IsHandleCreated)
{
BeginInvoke(new MethodInvoker(UpdateTickerInfoBarCore));
}
}
catch (Exception e) {
Telemetry.Default.TrackException(e);
}
}
public virtual BindingList <CandleStickData> GetCandleStickData(Ticker ticker, int candleStickPeriodMin, DateTime start, long periodInSeconds)
{
return(new BindingList <CandleStickData>());
}
void ClearChart()
{
this.tickerChartViewer1.Ticker = null;
}
public void Add(Ticker ticker)
{
Tickers[Count] = ticker;
Count++;
}
private void gridView1_GetThumbnailImage(object sender, DevExpress.XtraGrid.Views.Grid.GridViewThumbnailImageEventArgs e)
{
Ticker t = (Ticker)Exchange.Tickers[e.DataSourceIndex];
e.ThumbnailImage = new Bitmap(CurrencyLogoProvider.GetLogoImage(t.MarketCurrency), new Size(128, 128));
}
void UpdateGrid(Ticker info)
{
int rowHandle = this.gvTikers.GetRowHandle(info.Index);
this.gvTikers.RefreshRow(rowHandle);
}
protected virtual string GetTradeSocketAddress(Ticker ticker)
{
return(string.Empty);
}
public abstract bool UpdateArbitrageOrderBook(Ticker tickerBase, int depth);
public abstract bool UpdateOrderBook(Ticker tickerBase);
public bool IsTickerPinned(Ticker tickerBase)
{
return(PinnedTickers.FirstOrDefault(p => p.BaseCurrency == tickerBase.BaseCurrency && p.MarketCurrency == tickerBase.MarketCurrency) != null);
}
public virtual void StopListenKlineStream(Ticker ticker, CandleStickIntervalInfo info)
{
}
void BackgroundUpdateCandleSticks(DateTime date, bool inBackgroundThread)
{
if (this.isCandleSticksUpdate)
{
return;
}
this.isCandleSticksUpdate = true;
if (!inBackgroundThread)
{
try {
int seconds = CalculateTotalIntervalInSeconds();
ResizeableArray <CandleStickData> data = Ticker.GetCandleStickData(Ticker.CandleStickPeriodMin, date.AddSeconds(-seconds), seconds);
if (data != null)
{
UpdateCandleStickData(data);
UpdateChartSeries(data);
this.isCandleSticksUpdate = false;
}
else
{
}
}
catch (Exception e) {
Telemetry.Default.TrackException(e, new string[, ] {
{ "method", "update candlestick data from server" }
});
this.isCandleSticksUpdate = false;
}
return;
}
UpdateCandleStickThread = new Thread(() => {
try {
int seconds = CalculateTotalIntervalInSeconds();
ResizeableArray <CandleStickData> data = Ticker.GetCandleStickData(Ticker.CandleStickPeriodMin, date.AddSeconds(-seconds), seconds);
if (data != null)
{
lock (Ticker.CandleStickData) {
UpdateCandleStickData(data);
}
BeginInvoke(new Action <ResizeableArray <CandleStickData> >((d) => {
UpdateChartSeries(d);
this.isCandleSticksUpdate = false;
}), new object[] { data });
}
try {
SplashScreenManager.CloseDefaultWaitForm();
}
catch (Exception) {
this.isCandleSticksUpdate = false;
}
}
catch (Exception e) {
Telemetry.Default.TrackException(e, new string[, ] {
{ "method", "update candlestick data from server" }
});
}
});
try {
SplashScreenManager.ShowDefaultWaitForm("Loading chart from server...");
}
catch (Exception) {
}
try {
UpdateCandleStickThread.Start();
}
catch (Exception) {
XtraMessageBox.Show("error while running update thread. try again");
}
}
public abstract bool UpdateAccountTrades(AccountInfo account, Ticker ticker);
public abstract bool ProcessOrderBook(Ticker tickerBase, string text);
protected virtual string GetOrderBookSocketAddress(Ticker ticker)
{
return(string.Empty);
}
public abstract bool UpdateTicker(Ticker tickerBase);
private void MakeTrade(OrderType type)
{
if (!ValidateChildrenCore())
{
XtraMessageBox.Show("Not all fields are filled!");
return;
}
string validationError = string.Empty;
if (type == OrderType.Buy)
{
validationError = Ticker.ValidateTrade(Settings.BuyPrice, Settings.BuyAmount);
}
else
{
validationError = Ticker.ValidateTrade(Settings.SellPrice, Settings.SellAmount);
}
if (!string.IsNullOrEmpty(validationError))
{
XtraMessageBox.Show("Error validating trade. Values will be corrected. Error was: " + validationError);
double rate = 0;
double amount = 0;
if (type == OrderType.Buy)
{
rate = Settings.BuyPrice;
amount = Settings.BuyAmount;
}
else
{
rate = Settings.SellPrice;
amount = Settings.SellAmount;
}
Ticker.CorrectTrade(ref rate, ref amount);
if (type == OrderType.Buy)
{
Settings.BuyPrice = rate;
Settings.BuyAmount = amount;
}
else
{
Settings.SellPrice = rate;
Settings.SellAmount = amount;
}
return;
}
TradingResult res = null;
if (type == OrderType.Buy)
{
res = Ticker.Buy(Settings.BuyPrice, Settings.BuyAmount);
if (res == null)
{
XtraMessageBox.Show("Error buying. " + LogManager.Default.Messages.Last().Description);
return;
}
}
else
{
Settings.Enabled = false;
res = Ticker.Sell(Settings.SellPrice, Settings.SellAmount);
if (res == null)
{
XtraMessageBox.Show("Error selling. " + LogManager.Default.Messages.Last().Description);
return;
}
}
TradingResult = res;
if (Settings.Enabled)
{
Settings.Date = DateTime.UtcNow;
Ticker.Trailings.Add(Settings);
Settings.Start();
if (OperationsProvider != null)
{
OperationsProvider.ShowTradingResult(Ticker);
}
Ticker.Save();
XtraMessageBox.Show("Trailing added!");
}
RaiseOnTrade(res);
}
public abstract bool UpdateTrades(Ticker tickerBase);
public TradeInfoItem(AccountInfo account, Ticker ticker)
{
Account = account;
Ticker = ticker;
}
public abstract List <TradeInfoItem> GetTrades(Ticker ticker, DateTime starTime);
bool IsTickerPinned(Ticker t)
{
return(Exchange.PinnedTickers.FirstOrDefault(i => i.BaseCurrency == t.BaseCurrency && i.MarketCurrency == t.MarketCurrency) != null);
}
public abstract bool UpdateOpenedOrders(AccountInfo account, Ticker ticker);
protected virtual bool SyncToHighestBid(TickerCollection info, bool forceUpdateBalance, bool allowLog)
{
if (info == null)
{
return(false);
}
Ticker lowest = info.Arbitrage.LowestAskTicker;
Ticker highest = info.Arbitrage.HighestBidTicker;
if (forceUpdateBalance || lowest.MarketCurrencyBalance == 0)
{
if (!lowest.UpdateBalance(lowest.MarketCurrency))
{
if (allowLog)
{
LogManager.Default.Error("Cant update balance.", lowest.HostName + "-" + lowest.MarketCurrency);
}
if (allowLog)
{
LogManager.Default.ShowLogForm();
}
return(false);
}
if (!highest.UpdateBalance(highest.MarketCurrency))
{
if (allowLog)
{
LogManager.Default.Error("Cant update balance.", highest.HostName + "-" + highest.MarketCurrency);
}
if (allowLog)
{
LogManager.Default.ShowLogForm();
}
return(false);
}
}
string highAddress = highest.GetDepositAddress(highest.MarketCurrency);
if (string.IsNullOrEmpty(highAddress))
{
if (allowLog)
{
LogManager.Default.Error("Cant get deposit address.", highest.HostName + "-" + highest.MarketCurrency);
}
if (allowLog)
{
LogManager.Default.ShowLogForm();
}
return(false);
}
if (allowLog)
{
LogManager.Default.Log("Highest Bid Currency Deposit: " + highAddress);
}
double amount = lowest.MarketCurrencyBalance;
if (allowLog)
{
LogManager.Default.Log("Lowest Ask Currency Amount = " + amount.ToString("0.00000000"));
}
if (lowest.Withdraw(lowest.MarketCurrency, highAddress, "", amount))
{
string text = "Withdraw " + lowest.MarketCurrency + " " + lowest.HostName + " -> " + highest.HostName + " succeded.";
if (allowLog)
{
LogManager.Default.Success(text);
}
TelegramBot.Default.SendNotification(text);
return(true);
}
else
{
if (allowLog)
{
LogManager.Default.Error("Withdraw " + lowest.MarketCurrency + " " + lowest.HostName + " -> " + highest.HostName + " failed.");
}
return(false);
}
}
public abstract TradingResult Sell(AccountInfo account, Ticker ticker, double rate, double amount);
public TickerUpdateHelper(Ticker ticker)
{
Ticker = ticker;
}
void UpdateChart()
{
this.tickerChartViewer1.Ticker = Ticker;
}
