private async Task ParseMessage(SocketEventHandlerArgs msg)
{
string symbol = msg.chnlName;
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
if (String.IsNullOrEmpty(jsonResponse))
{
_logger.Log(LogPriority.Warning, $"<--Report : Empty message received - '{jsonResponse}' : ", ExchName);
return;
}
if (symbol.Equals(BinanceClient.connectSymbol + "@ticker"))
{
return;
}
JObject jToken = JObject.Parse(jsonResponse);
var symbolItem = jToken["s"].ToString();
MarketBook mb = new MarketBook()
{
AskPrice = jToken["a"].ToObject <double>(),
AskSize = jToken["A"].ToObject <double>(),
BidPrice = jToken["b"].ToObject <double>(),
BidSize = jToken["B"].ToObject <double>(),
ServerTime = new DateTime(1970, 1, 1, 0, 0, 0, 0).AddMilliseconds(jToken["E"].ToObject <double>()),
LocalTime = DateTime.Now
};
_client.OnReport(ExchName, ExchName + symbolItem, mb);
}
break;
case StreamMessageType.Logon:
{
_client.OnEvent(ExchName, BrokerEvent.ConnectorStarted, string.Empty);
using (await _lock.LockAsync())
{
if (SubscribeList.Count > 0)
{
foreach (var i in SubscribeList)
{
chnl = new WebSocketWrapper(Uri + i.Key, i.Key, _logger, ExchName);
await chnl.Start(ParseMessage);
}
}
}
}
break;
default:
break;
}
}
private async Task ParseMessage(SocketEventHandlerArgs msg)
{
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
if (jsonResponse == "[]")
{
return;
}
if (jsonResponse.Contains("tick_id"))
{
var tickerResponse = JsonConvert.DeserializeObject <TickerResponse>(jsonResponse);
using (await _lock.LockAsync())
{
string symbol = "";
var temp = [email protected]('_');
if (temp.Count() == 4)
{
symbol = temp[2] + "_" + temp[3];
}
else
if (temp.Count() == 5)
{
symbol = temp[2] + "_" + temp[3] + "_" + temp[4];
}
var symbolId = symbol.GetHashCode();
Subscribe data;
if (SubscribeList.TryGetValue(symbolId, out data))
{
data.market = new MarketBook()
{
AskPrice = Convert.ToDouble([email protected]_ask),
AskSize = Convert.ToDouble([email protected]_ask_size),
BidPrice = Convert.ToDouble([email protected]_bid),
BidSize = Convert.ToDouble([email protected]_bid_size),
LocalTime = DateTime.Now,
ServerTime = [email protected],
LastPrice = [email protected],
LastSize = [email protected]
};
_client.OnReport(Name, data.pair.Id(), data.market);
}
}
}
}
break;
case StreamMessageType.Error:
break;
case StreamMessageType.Logon:
{
_client.OnEvent(Name, BrokerEvent.ConnectorStarted, string.Empty);
using (await _lock.LockAsync())
{
foreach (var item in SubscribeList)
{
var symbol = item.Key;
if (item.Value.mode == SubscriptionModel.TopBook)
{
string channelName = "lightning_ticker_" + symbol;
var symbolId = symbol.GetHashCode();
var request =
new
{
method = "subscribe",
@params = new { channel = channelName },
id = symbolId,
};
string paramData = JsonConvert.SerializeObject(request, Formatting.Indented);
await chnl.SendCommand(Encoding.UTF8.GetBytes(paramData));
}
}
}
}
break;
case StreamMessageType.Logout:
_client.OnEvent(Name, BrokerEvent.SessionLogout, "");
break;
default:
break;
}
}
private async Task ParseMessage(SocketEventHandlerArgs msg)
{
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
if (jsonResponse.Contains("error"))
{
JObject jToken;
jToken = JObject.Parse(jsonResponse);
var dict = jToken["error"].ToObject <Dictionary <string, string> >();
_client.OnEvent(Name, BrokerEvent.InternalError, "Message: " + dict["message"] + ", Description: " + dict["description"]);
}
else if (jsonResponse.Contains("method"))
{
var response = JsonConvert.DeserializeObject <TickerResponse>(jsonResponse);
var method = response.method;
var symbol = [email protected];
var data = response.@params;
if (method == "ticker" && SubscribeList.ContainsKey(symbol))
{
MarketBook mb = new MarketBook()
{
LocalTime = DateTime.Now,
ServerTime = data.timestamp,
AskPrice = Convert.ToDouble(data.ask),
BidPrice = Convert.ToDouble(data.bid),
LastPrice = Convert.ToDouble(data.last),
LastSize = Convert.ToDouble(data.volume),
};
_client.OnReport(Name, SubscribeList[symbol].pair.Id(), mb);
}
}
}
break;
case StreamMessageType.Error:
break;
case StreamMessageType.Logon:
{
_client.OnEvent(Name, BrokerEvent.ConnectorStarted, string.Empty);
using (await _lock.LockAsync())
{
foreach (var item in SubscribeList)
{
var symbol = item.Key;
var request = $"{{\"method\":\"subscribeTicker\",\"params\":{{ \"symbol\":\"{item.Value.pair.Symbol}\"}}, \"id\": \"123\"}}";
await chnl.SendCommand(Encoding.UTF8.GetBytes(request));
}
}
}
break;
case StreamMessageType.Logout:
_client.OnEvent(Name, BrokerEvent.SessionLogout, "");
break;
default:
break;
}
}
private async Task ParseMessage(SocketEventHandlerArgs msg)
{
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
if (jsonResponse == "[]")
{
return;
}
if (jsonResponse.Contains("1002"))
{
JArray token = JArray.Parse(jsonResponse);
if (token[2].HasValues)
{
var chnlKey = Convert.ToInt32(token[2][0]);
if (SubscribeList.ContainsKey(chnlKey))
{
MarketBook mb = new MarketBook()
{
AskPrice = token[2][2].ToObject <double>(),
BidPrice = token[2][3].ToObject <double>(),
LastSize = token[2][1].ToObject <double>(),
LocalTime = DateTime.Now
};
_client.OnReport(Name, SubscribeList[chnlKey].pair.Id(), mb);
}
}
}
}
break;
case StreamMessageType.Logon:
_client.OnEvent(Name, BrokerEvent.ConnectorStarted, string.Empty);
using (await _lock.LockAsync())
{
foreach (var item in SubscribeList)
{
var symbol = item.Key;
if (item.Value.mode == SubscriptionModel.TopBook)
{
string paramData = $"{{\"command\":\"subscribe\",\"channel\":\"1002\"}}";
await chnl.SendCommand(Encoding.UTF8.GetBytes(paramData));
}
}
}
break;
case StreamMessageType.Logout:
_client.OnEvent(Name, BrokerEvent.SessionLogout, "");
break;
case StreamMessageType.Error:
break;
default:
break;
}
}
private async Task ParseMessage(SocketEventHandlerArgs msg)
{
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
if (jsonResponse == "[]")
{
return;
}
string evnt = "";
JObject jToken = JObject.Parse(jsonResponse);
evnt = jToken["event"]?.Value <string>();
var data = jToken["data"];
if (evnt == "data")
{
string symbol = jToken["channel"].ToString().Remove(0, 11);
var result = JsonConvert.DeserializeObject <OrderBookResponse>(data.ToString());
Subscribe dataItem;
if (SubscribeList.TryGetValue(symbol, out dataItem))
{
MarketBook mb = new MarketBook()
{
AskPrice = Convert.ToDouble(result.asks[0][0]),
BidPrice = Convert.ToDouble(result.bids[0][0]),
LocalTime = DateTime.Now,
ServerTime = new DateTime(1970, 1, 1, 0, 0, 0, 0).AddSeconds(Convert.ToDouble(result.timestamp))
};
_client.OnReport(Name, dataItem.pair.Id(), mb);
}
}
}
break;
case StreamMessageType.Error:
break;
case StreamMessageType.Logon:
{
_client.OnEvent(Name, BrokerEvent.ConnectorStarted, string.Empty);
using (await _lock.LockAsync())
{
foreach (var item in SubscribeList)
{
var symbol = item.Key;
var request = "{\"event\":\"pusher:subscribe\",\"data\":{\"channel\":\"order_book_" + symbol + "\"}}";
await chnl.SendCommand(Encoding.UTF8.GetBytes(request));
_client.OnEvent(Name, BrokerEvent.CoinSubscribed, symbol);
_logger.Log(LogPriority.Info, "Coin Subscribed - " + symbol, Name);
}
}
}
break;
case StreamMessageType.Logout:
_client.OnEvent(Name, BrokerEvent.SessionLogout, "");
break;
default:
break;
}
}
private async Task ParseMessage(SocketEventHandlerArgs msg)
{
string symbol = msg.chnlName;
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
if (String.IsNullOrEmpty(jsonResponse))
{
_logger.Log(LogPriority.Warning, $"<--Report : Empty message received - '{jsonResponse}' : ", ExchName);
return;
}
if (symbol.Equals(GeminiClient.connectSymbol))
{
return;
}
JObject jToken = JObject.Parse(jsonResponse);
var type = jToken["type"]?.Value <string>();
if (type == "update")
{
var subscribeResponse = JsonConvert.DeserializeObject <Update>(jsonResponse);
if (jsonResponse.Contains("initial"))
{
SortedDictionary <double, double> ask_book = new SortedDictionary <double, double>();
SortedDictionary <double, double> bid_book = new SortedDictionary <double, double>();
foreach (var item in subscribeResponse.events)
{
if (item.side == "ask")
{
ask_book.Add(item.price, item.remaining);
}
else
if (item.side == "bid")
{
bid_book.Add(item.price, item.remaining);
}
}
using (await _lock.LockAsync())
{
SubscribeList.Add(symbol, new Subscribe()
{
market = new Market()
{
buy_list = bid_book,
sell_list = ask_book,
ServerTime = subscribeResponse.timestampms
}
});
_client.OnEvent(ExchName, BrokerEvent.CoinSubscribed, symbol);
_logger.Log(LogPriority.Info, "Coin Subscribed - " + symbol, ExchName);
SendReport(symbol, SubscribeList[symbol]);
}
}
else
{
foreach (var eventItem in subscribeResponse.events)
{
if (eventItem.reason == "cancel" && eventItem.type == "change")
{
var price = eventItem.price;
var size = eventItem.remaining;
var side = eventItem.side;
Subscribe data;
if (SubscribeList.TryGetValue(symbol, out data))
{
using (await _lock.LockAsync())
{
if (side == "ask")
{
if (!data.market.sell_list.ContainsKey(price))
{
_logger.Log(LogPriority.Error, $"this Price '-{price}-' not exists for delete", symbol);
}
else
if (size == 0)
{
data.market.sell_list.Remove(price);
}
else
{
data.market.sell_list.Remove(price);
data.market.sell_list.Add(price, size);
}
}
else
if (side == "bid")
{
if (!data.market.buy_list.ContainsKey(price))
{
_logger.Log(LogPriority.Error, $"this Price '-{price}-' not exists for delete", symbol);
}
else
if (size == 0)
{
data.market.buy_list.Remove(price);
}
else
{
data.market.buy_list.Remove(price);
data.market.buy_list.Add(price, size);
}
}
data.market.ServerTime = subscribeResponse.timestampms;
SendReport(symbol, SubscribeList[symbol]);
}
}
}
else
if ((eventItem.reason == "place" || eventItem.reason == "trade") && eventItem.type == "change")
{
var price = eventItem.price;
var size = eventItem.remaining;
var side = eventItem.side;
Subscribe data;
if (SubscribeList.TryGetValue(symbol, out data))
{
using (await _lock.LockAsync())
{
if (side == "ask")
{
if (data.market.sell_list.ContainsKey(price) && data.market.sell_list[price] == size)
{
_logger.Log(LogPriority.Error, $"this Price '-{price}-' already exists", symbol);
}
else
if (data.market.sell_list.ContainsKey(price) && data.market.sell_list[price] != size)
{
data.market.sell_list[price] = size;
}
else
if (size == 0)
{
data.market.sell_list.Remove(price);
}
else
{
data.market.sell_list.Add(price, size);
}
}
else
if (side == "bid")
{
if (data.market.buy_list.ContainsKey(price) && data.market.buy_list[price] == size)
{
_logger.Log(LogPriority.Error, $"this Price '-{price}-' already exists", symbol);
}
else
if (data.market.buy_list.ContainsKey(price) && data.market.buy_list[price] != size)
{
data.market.buy_list[price] = size;
}
else
if (size == 0)
{
data.market.buy_list.Remove(price);
}
else
{
data.market.buy_list.Add(price, size);
}
}
}
}
data.market.ServerTime = subscribeResponse.timestampms;
SendReport(symbol, SubscribeList[symbol]);
}
}
}
}
}
break;
case StreamMessageType.Logon:
{
_client.OnEvent(ExchName, BrokerEvent.ConnectorStarted, string.Empty);
using (await _lock.LockAsync())
{
if (SubscribeList.Count > 0)
{
foreach (var i in SubscribeList)
{
chnl = new WebSocketWrapper(Uri + i.Key, i.Key, _logger, ExchName);
await chnl.Start(ParseMessage);
}
}
}
}
break;
default:
break;
}
}
private async Task ParseMessage(SocketEventHandlerArgs msg)
{
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
if (jsonResponse == "[]")
{
return;
}
string evnt = "";
JObject jToken = JObject.Parse(jsonResponse);
evnt = jToken["event"]?.Value <string>();
var data = jToken["data"].ToString();
if (evnt == "updated")
{
var result = JsonConvert.DeserializeObject <Ticker>(data);
string symbol = result.currency_pair_code.ToLower();
Subscribe dataItem;
if (SubscribeList.TryGetValue(symbol, out dataItem))
{
MarketBook mb = new MarketBook()
{
AskPrice = Convert.ToDouble(result.market_ask),
BidPrice = Convert.ToDouble(result.market_bid),
LastPrice = Convert.ToDouble(result.last_traded_price),
LastSize = Convert.ToDouble(result.last_traded_quantity),
LocalTime = DateTime.Now,
};
_client.OnReport(Name, dataItem.pair.Id(), mb);
}
}
}
break;
case StreamMessageType.Error:
break;
case StreamMessageType.Logon:
{
var _pairs = await GetProducts();
using (await _lock.LockAsync())
{
foreach (var item in SubscribeList)
{
var symbol = item.Key;
var chnlId = _pairs[symbol];
var req = "product_cash_" + symbol + "_" + chnlId;
var request = $"{{\"event\":\"pusher:subscribe\",\"data\":{{\"channel\":\"{req}\"}}}}";
await chnl.SendCommand(Encoding.UTF8.GetBytes(request));
_client.OnEvent(Name, BrokerEvent.CoinSubscribed, symbol);
_logger.Log(LogPriority.Info, "Coin Subscribed - " + symbol, Name);
}
}
_client.OnEvent(Name, BrokerEvent.ConnectorStarted, string.Empty);
}
break;
case StreamMessageType.Logout:
_client.OnEvent(Name, BrokerEvent.SessionLogout, "");
break;
default:
break;
}
}
private async Task ParseMessage(SocketEventHandlerArgs msg)
{
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
if (jsonResponse == "[]")
{
return;
}
string type = "";
JObject jToken = JObject.Parse(jsonResponse);
type = jToken["type"]?.Value <string>();
if (type == "error")
{
if (jToken["message"]?.Value <string>() == "Failed to subscribe")
{
_client.OnEvent(Name, BrokerEvent.CoinSubscribedFault, jToken["reason"]?.Value <string>());
_client.OnEvent(Name, BrokerEvent.InternalError, jToken["reason"]?.Value <string>());
}
}
else
if (type == "ticker")
{
string symbol = jToken["product_id"].ToString();
MarketBook mb = new MarketBook()
{
AskPrice = (double)jToken["best_ask"],
BidPrice = (double)jToken["best_bid"],
LocalTime = DateTime.Now,
};
_client.OnReport(Name, Name + symbol.Replace("-", ""), mb);
}
}
break;
case StreamMessageType.Error:
break;
case StreamMessageType.Logon:
{
_client.OnEvent(Name, BrokerEvent.ConnectorStarted, string.Empty);
_client.OnEvent(Name, BrokerEvent.SessionLogon, "");
using (await _lock.LockAsync())
{
foreach (var item in SubscribeList)
{
var symbol = item.Key;
if (item.Value.mode == SubscriptionModel.TopBook)
{
var request = new
{
type = "subscribe",
product_ids = new List <string>()
{
symbol
},
channels = new List <string>()
{
"ticker"
},
};
string paramData = JsonConvert.SerializeObject(request, Formatting.Indented);
await chnl.SendCommand(Encoding.UTF8.GetBytes(paramData));
}
}
}
}
break;
case StreamMessageType.Logout:
_client.OnEvent(Name, BrokerEvent.SessionLogout, "");
break;
default:
break;
}
}
private async Task ParseMessage(SocketEventHandlerArgs msg)
{
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
if (jsonResponse == "[]")
{
return;
}
if (jsonResponse.Contains("auth"))
{
_client.OnEvent(Name, BrokerEvent.Info, "Authentification success");
}
else
if (jsonResponse.Contains("ping"))
{
var request = new
{
e = "pong"
};
string paramData = JsonConvert.SerializeObject(request, Formatting.Indented);
await chnl.SendCommand(Encoding.UTF8.GetBytes(paramData));
}
else
if (jsonResponse.Contains("order-book-subscribe"))
{
var tickerResponse = JsonConvert.DeserializeObject <Response>(jsonResponse);
string symbol = tickerResponse.oid;
long time = tickerResponse.data.timestamp;
Subscribe data;
if (SubscribeList.TryGetValue(symbol, out data))
{
using (await _lock.LockAsync())
{
foreach (var bid in tickerResponse.data.bids)
{
if (!data.market.bid_list.ContainsKey(bid[0]))
{
data.market.bid_list.Add(bid[0], bid[1]);
}
}
foreach (var ask in tickerResponse.data.asks)
{
if (!data.market.ask_list.ContainsKey(ask[0]))
{
data.market.ask_list.Add(ask[0], ask[1]);
}
}
MarketBook mb = new MarketBook()
{
LocalTime = DateTime.Now,
ServerTime = new DateTime(1970, 1, 1, 0, 0, 0, 0).AddSeconds(time),
AskPrice = data.market.ask_list.First().Key,
AskSize = data.market.ask_list.First().Value,
BidPrice = data.market.bid_list.Last().Key,
BidSize = data.market.bid_list.Last().Value,
};
_client.OnReport(Name, data.pair.Id(), mb);
}
}
}
else
if (jsonResponse.Contains("md_update"))
{
var updateResponse = JsonConvert.DeserializeObject <Response>(jsonResponse);
string symbol = updateResponse.data.pair;
long time = updateResponse.data.time;
Subscribe data;
if (SubscribeList.TryGetValue(symbol, out data))
{
using (await _lock.LockAsync())
{
if (updateResponse.data.asks.Count != 0)
{
foreach (var ask in updateResponse.data.asks)
{
var askPrice = ask[0];
var askSize = ask[1];
if (askSize == 0.0)
{
if (!data.market.ask_list.ContainsKey(askPrice))
{
_logger.Log(LogPriority.Error, $"this Price '-{askPrice}-' not exists for delete", Name);
}
else
{
data.market.ask_list.Remove(askPrice);
}
}
else
{
if (data.market.ask_list.ContainsKey(askPrice))
{
data.market.ask_list[askPrice] = askSize;
}
else
{
data.market.ask_list.Add(askPrice, askSize);
}
}
}
}
else
if (updateResponse.data.bids.Count != 0)
{
foreach (var bid in updateResponse.data.bids)
{
var bidPrice = bid[0];
var bidSize = bid[1];
if (bidSize == 0.0)
{
data.market.bid_list.Remove(bidPrice);
}
else
{
if (data.market.bid_list.ContainsKey(bidPrice))
{
if (bidSize == data.market.bid_list[bidPrice])
{
_logger.Log(LogPriority.Error, $"this Price '-{bidPrice}-' not changed", Name);
}
else
{
data.market.bid_list[bidPrice] = bidSize;
}
}
else
{
data.market.bid_list.Add(bidPrice, bidSize);
}
}
}
}
}
MarketBook mb = new MarketBook()
{
LocalTime = DateTime.Now,
ServerTime = new DateTime(1970, 1, 1, 0, 0, 0, 0).AddMilliseconds(time),
AskPrice = data.market.ask_list.First().Key,
AskSize = data.market.ask_list.First().Value,
BidPrice = data.market.bid_list.Last().Key,
BidSize = data.market.bid_list.Last().Value,
};
_client.OnReport(Name, data.pair.Id(), mb);
}
}
}
break;
case StreamMessageType.Error:
break;
case StreamMessageType.Logon:
{
await Authentification();
_client.OnEvent(Name, BrokerEvent.ConnectorStarted, string.Empty);
using (await _lock.LockAsync())
{
foreach (var item in SubscribeList)
{
var symbol = item.Key;
var request = new Request
{
e = "order-book-subscribe",
data = new DataRequest {
pair = new List <string>()
{
item.Value.pair.First, item.Value.pair.Second
}, subscribe = true, depth = 0
},
oid = symbol
};
string paramData = JsonConvert.SerializeObject(request, Formatting.Indented);
await chnl.SendCommand(Encoding.UTF8.GetBytes(paramData));
}
}
}
break;
case StreamMessageType.Logout:
_client.OnEvent(Name, BrokerEvent.SessionLogout, "");
break;
default:
break;
}
}
private async Task ParseMessage(SocketEventHandlerArgs msg)
{
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
JObject jToken;
JArray jT;
if (!jsonResponse.Contains('{') && !jsonResponse.Contains("hb"))
{
jT = JArray.Parse(jsonResponse);
switch (jT[0].ToString())
{
case "0":
break;
default:
{
if (SubscribeList.ContainsKey((int)jT[0]))
{
var chn = SubscribeList[(int)jT[0]];
if (chn.name == "ticker")
{
_client.OnReport(Name, chn.Id,
new MarketBook()
{
BidPrice = (double)jT[1][0],
AskPrice = (double)jT[1][2],
BidSize = (double)jT[1][1],
AskSize = (double)jT[1][3],
LastPrice = (double)jT[1][6],
LocalTime = DateTime.Now,
});
break;
}
}
}
break;
}
}
else
{
if (jsonResponse.Contains("\"hb\"") || jsonResponse.Contains("\"ps\"") || jsonResponse.Contains("\"os\"") || jsonResponse.Contains("\"ws\""))
{
return;
}
jToken = JObject.Parse(jsonResponse);
var type = jToken["event"]?.Value <string>();
switch (type)
{
case "subscribed":
{
var cId = Utilities.StrToInstr(jToken["pair"].Value <string>(), Name).Id();
using (await _lock.LockAsync())
{
SubscribeList.Add(jToken["chanId"].Value <int>(), new SubscribeChannels("ticker", jToken["pair"].Value <string>(), new MarketBook(), cId));
}
_logger.Log(LogPriority.Info, $"Channel {cId} - {jToken["channel"].Value<string>()} is subscribed.", Name);
_client.OnEvent(Name, BrokerEvent.CoinSubscribed, cId);
break;
}
case "unsubscribed":
{
using (await _lock.LockAsync())
{
if (SubscribeList.ContainsKey(jToken["chanId"].Value <int>()))
{
var chId = SubscribeList[jToken["chanId"].Value <int>()].Id;
SubscribeList.Remove(jToken["chanId"].Value <int>());
_logger.Log(LogPriority.Info, $"Channel '{chId.ToString()}' is unsubscribed.", Name);
_client.OnEvent(Name, BrokerEvent.CoinUnsubscribed, chId.ToString());
}
}
break;
}
case "error":
{
var code = jToken["code"]?.Value <string>();
_logger.Log(LogPriority.Info, jToken["msg"].ToString(), Name);
switch (code)
{
/*
* Error Codes
* 10300 : Subscription failed (generic)
* 10301 : Already subscribed
* 10302 : Unknown channel
* 10400 : Unsubscription failed (generic)
* 10401 : Not subscribed
*/
case "10300":
case "10301":
case "10302":
{
using (await _lock.LockAsync())
{
var ch = SubscribeList.Where(u => u.Value.pair.Contains(jToken["pair"].Value <string>()) && u.Value.name == jToken["channel"].Value <string>()).FirstOrDefault();
if (ch.Value != null)
{
_client.OnEvent(Name, BrokerEvent.CoinSubscribedFault, ch.Value.Id);
SubscribeList.Remove(ch.Key);
}
else
{
_client.OnEvent(Name, BrokerEvent.InternalError, jToken["msg"].ToString());
}
}
break;
}
case "10401":
case "10400":
{
var ch = SubscribeList.Where(u => u.Value.pair.Contains(jToken["pair"].Value <string>()) && u.Value.name == jToken["channel"].Value <string>()).FirstOrDefault();
if (ch.Value != null)
{
_client.OnEvent(Name, BrokerEvent.CoinUnsubscribedFault, ch.Value.Id);
}
break;
}
default:
{
{
_client.OnEvent(Name, BrokerEvent.InternalError, jToken["msg"].ToString());
break;
}
}
}
break;
}
default:
{
_client.OnEvent(Name, BrokerEvent.Info, jsonResponse);
break;
}
}
}
}
break;
case StreamMessageType.Error:
break;
case StreamMessageType.Logon:
{
_client.OnEvent(Name, BrokerEvent.ConnectorStarted, string.Empty);
using (await _lock.LockAsync())
{
foreach (var item in SubscribeList)
{
var request = $"{{\"event\":\"subscribe\",\"channel\":\"ticker\", \"symbol\": \"{item.Value.pair}\"}}";
await chnl.SendCommand(Encoding.UTF8.GetBytes(request));
}
}
}
break;
case StreamMessageType.Logout:
_client.OnEvent(Name, BrokerEvent.SessionLogout, "");
break;
default:
break;
}
}
private async Task ParseMessage(SocketEventHandlerArgs msg)
{
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
if (jsonResponse == "[]")
{
return;
}
if (jsonResponse.Contains("depth.update"))
{
var depthResponse = JsonConvert.DeserializeObject <GateIOUpdateResponse>(jsonResponse);
var status = depthResponse.@params[0].ToString();
var askbid = depthResponse.@params[1].ToString();
var symbol = depthResponse.@params[2].ToString();
if (status == "True")
{
var askbidResponse = JsonConvert.DeserializeObject <AskBidResponse>(askbid);
var symbolId = symbol.GetHashCode();
Subscribe data;
if (SubscribeList.TryGetValue(symbolId, out data))
{
using (await _lock.LockAsync())
{
SubscribeList[symbolId].market = new MarketBook()
{
AskPrice = Convert.ToDouble(askbidResponse.asks[0][0]),
AskSize = Convert.ToDouble(askbidResponse.asks[0][1]),
BidPrice = Convert.ToDouble(askbidResponse.bids[0][0]),
BidSize = Convert.ToDouble(askbidResponse.bids[0][1]),
LocalTime = DateTime.Now
};
_client.OnReport(Name, data.pair.Id(), SubscribeList[symbolId].market);
}
}
}
else
if (status == "False")
{
var askbidResponse = JsonConvert.DeserializeObject <AskBidResponse>(askbid);
var symbolId = symbol.GetHashCode();
Subscribe data;
if (SubscribeList.TryGetValue(symbolId, out data))
{
using (await _lock.LockAsync())
{
if (askbidResponse.asks != null)
{
if (askbidResponse.asks.Count == 1)
{
data.market.AskPrice = Convert.ToDouble(askbidResponse.asks[0][0]);
data.market.AskSize = Convert.ToDouble(askbidResponse.asks[0][1]);
}
else
if (askbidResponse.asks.Count == 2)
{
data.market.AskPrice = Convert.ToDouble(askbidResponse.asks[1][0]);
data.market.AskSize = Convert.ToDouble(askbidResponse.asks[1][1]);
}
}
if (askbidResponse.bids != null)
{
if (askbidResponse.bids.Count == 1)
{
data.market.BidPrice = Convert.ToDouble(askbidResponse.bids[0][0]);
data.market.BidSize = Convert.ToDouble(askbidResponse.bids[0][1]);
}
else
if (askbidResponse.bids.Count == 2)
{
data.market.BidPrice = Convert.ToDouble(askbidResponse.bids[1][0]);
data.market.BidSize = Convert.ToDouble(askbidResponse.bids[1][1]);
}
}
data.market.LocalTime = DateTime.Now;
_client.OnReport(Name, data.pair.Id(), SubscribeList[symbolId].market);
}
}
}
}
}
break;
case StreamMessageType.Error:
break;
case StreamMessageType.Logon:
{
_client.OnEvent(Name, BrokerEvent.ConnectorStarted, string.Empty);
using (await _lock.LockAsync())
{
foreach (var item in SubscribeList)
{
var symbol = item.Key;
if (item.Value.mode == SubscriptionModel.TopBook)
{
var request = new
{
id = symbol.GetHashCode(),
method = "depth.subscribe",
@params = new List <object>()
{
symbol, 1, "0"
}
};
string paramData = JsonConvert.SerializeObject(request, Formatting.Indented);
await chnl.SendCommand(Encoding.UTF8.GetBytes(paramData));
}
}
}
}
break;
case StreamMessageType.Logout:
_client.OnEvent(Name, BrokerEvent.SessionLogout, "");
break;
default:
break;
}
}
