public void ChangeRate(string pair, BidAsk bidAsk)
{
var p = CurrencyPair.Parse(pair);
var index = coinAverageMock.ExchangeRates.FindIndex(o => o.CurrencyPair == p);
coinAverageMock.ExchangeRates[index] = new PairRate(p, bidAsk);
}
protected override StreamResponse ParseJson(string json)
{
var data = JsonConvert.DeserializeObject <JsonPrice>(json);
if (data.Kind == JsonPriceKind.Price &&
data.Bids.Count > 0 && data.Asks.Count > 0)
{
var tickOnEst = data.DateTimeUtc.ToEstFromUtc();
if (!tickOnEst.IsTickOnEst())
{
return(GetHeartbeatResponse(data.DateTimeUtc));
}
var bidAsk = new BidAsk()
{
TickOnEst = tickOnEst,
Asset = WellKnown.Assets[
SymbolMap.InstrumentToSymbol[data.BrokerSymbol]],
IsTradable = data.IsTradeable,
Bid = new Bucket()
{
Price = data.Bids[0].Price,
Liquidity = data.Bids[0].Liquidity
},
Ask = new Bucket()
{
Price = data.Asks[0].Price,
Liquidity = data.Asks[0].Liquidity
}
};
var results = new List <ValidationResult>();
if (bidAsk.TryValidate(results))
{
return(new PriceResponse()
{
Kind = ResponseKind.Price,
DateTimeUtc = data.DateTimeUtc,
BidAsk = bidAsk
});
}
else
{
return(new BadPriceResponse()
{
Kind = ResponseKind.BadPrice,
DateTimeUtc = data.DateTimeUtc,
Json = json,
Results = results
});
}
}
else if (data.Kind != JsonPriceKind.Heartbeat)
{
}
return(GetHeartbeatResponse(data.DateTimeUtc));
}
public void Update(UpdateBidAsk item)
{
if (item.Row != 0)
{
this.rawData.Remove(item);
return;
}
BidAsk bidAsk = GetBidAsk(item.Symbol);
BidAsk ba = MakeBidAsk(item);
this.rawData.Remove(item);
if (bidAsk != null)
{
this.tradingData.Get <ICollection <BidAsk> >().Remove(bidAsk);
}
this.logger.Log(String.Format("{0:dd/MM/yyyy H:mm:ss.fff}, {1}, UpdateBidAsk преобразован в BidAsk, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}",
BrokerDateTime.Make(DateTime.Now),
this.GetType().Name,
ba.Symbol,
ba.Row,
ba.NRows,
ba.Bid,
ba.BidSize,
ba.Ask,
ba.AskSize,
ba.DateTime));
this.tradingData.Get <ObservableCollection <BidAsk> >().Add(ba);
}
private bool TryToBidAsk(JProperty p, out BidAsk bidAsk)
{
bidAsk = null;
if (Exchange == CoinAverageName)
{
JToken last = p.Value["last"];
if (!decimal.TryParse(last.Value <string>(), System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var v) ||
v <= 0)
{
return(false);
}
bidAsk = new BidAsk(v);
return(true);
}
else
{
JToken bid = p.Value["bid"];
JToken ask = p.Value["ask"];
if (bid == null || ask == null ||
!decimal.TryParse(bid.Value <string>(), System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var v1) ||
!decimal.TryParse(ask.Value <string>(), System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var v2) ||
v1 > v2 ||
v1 <= 0 || v2 <= 0)
{
return(false);
}
bidAsk = new BidAsk(v1, v2);
return(true);
}
}
public void Add_BidAsk_Record_On_UpdateBidAsk_With_Non_Zero_Row()
{
DateTime itemDate = BrokerDateTime.Make(DateTime.Now);
Assert.AreEqual(0, this.tradingData.Get <IEnumerable <BidAsk> >().Count());
this.rawData.Add(new UpdateBidAsk("RTS-6.13_FT", 0, 1, 150000, 100, 151000, 50));
Assert.AreEqual(0, this.rawData.Count);
Assert.AreEqual(1, this.tradingData.Get <IEnumerable <BidAsk> >().Count());
BidAsk item = this.tradingData.Get <IEnumerable <BidAsk> >().Last();
Assert.AreEqual("RTS-6.13_FT", item.Symbol);
Assert.AreEqual(0, item.Row);
Assert.AreEqual(1, item.NRows);
Assert.AreEqual(150000, item.Bid);
Assert.AreEqual(100, item.BidSize);
Assert.AreEqual(151000, item.Ask);
Assert.AreEqual(50, item.AskSize);
Assert.AreEqual(itemDate.Year, item.DateTime.Year);
Assert.AreEqual(itemDate.Month, item.DateTime.Month);
Assert.AreEqual(itemDate.Day, item.DateTime.Day);
Assert.AreEqual(itemDate.Hour, item.DateTime.Hour);
Assert.AreEqual(itemDate.Minute, item.DateTime.Minute);
Assert.AreEqual(itemDate.Second, item.DateTime.Second);
}
public static BidAskNoSql Create(BidAsk quote)
{
return(new BidAskNoSql()
{
PartitionKey = BidAskNoSql.GeneratePartitionKey(quote.LiquidityProvider),
RowKey = BidAskNoSql.GenerateRowKey(quote.Id),
Quote = quote
});
}
/// <summary>
/// GET: Requests the current market Tick from BTC Markets
/// </summary>
/// <returns>{"bestBid":13700000000,"bestAsk":14000000000,"lastPrice":14000000000,"currency":"AUD","instrument":"BTC","timestamp":1378878117}</returns>
public BidAsk GetTicker(string pair)
{
var bidAsk = new BidAsk();
var response = SendRequest("/market/" + pair + "/tick", null);
bidAsk.Bid = Convert.ToDecimal(response.Split(new string[] { "bestBid\":" }, StringSplitOptions.None)[1].Split(',')[0]);
bidAsk.Ask = Convert.ToDecimal(response.Split(new string[] { "bestAsk\":" }, StringSplitOptions.None)[1].Split(',')[0]);
return(bidAsk);
}
public void EmitMarketDepth(Instrument instrument, DateTime time, BidAsk side, OrderBookAction action, double price, int size, int position)
{
MarketDepth marketDepth = new MarketDepth(time, string.Empty, position, EnumConverter.Convert(action), EnumConverter.Convert(side), price, size);
if (this.NewMarketDepth == null)
{
return;
}
this.NewMarketDepth((object)this, new MarketDepthEventArgs(marketDepth, (IFIXInstrument)instrument.instrument, (IMarketDataProvider)this));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JArray ja = JArray.Load(reader);
BidAsk data = new BidAsk
{
Price = (string)ja[0],
Volume = (string)ja[1]
};
return(data);
}
internal static MDSide Convert(BidAsk side)
{
switch (side)
{
case BidAsk.Bid:
return(MDSide.Bid);
case BidAsk.Ask:
return(MDSide.Ask);
default:
throw new NotSupportedException(string.Format("BidAsk is not supported - {0}", side));
}
}
public void BidAsk_Constructor_test()
{
DateTime date = BrokerDateTime.Make(DateTime.Now);
BidAsk item = new BidAsk(1, date, "RTS-9.13_FT", 0, 10, 150, 10, 151, 15);
Assert.AreEqual(1, item.Id);
Assert.AreEqual(date, item.DateTime);
Assert.AreEqual("RTS-9.13_FT", item.Symbol);
Assert.AreEqual(0, item.Row);
Assert.AreEqual(10, item.NRows);
Assert.AreEqual(150, item.Bid);
Assert.AreEqual(10, item.BidSize);
Assert.AreEqual(151, item.Ask);
Assert.AreEqual(15, item.AskSize);
}
public BidAsk SetState(IEnumerable <OrderBookNoSql> entity)
{
_data = entity.ToDictionary(e => e.Level.OrderId) ?? throw new ArgumentNullException(nameof(entity), "Cannot init manager with null data");
_ask = _data.Values.Where(e => e.Side == OrderSide.Sell).OrderBy(e => e.Level.Price).FirstOrDefault()?.Level;
_bid = _data.Values.Where(e => e.Side == OrderSide.Buy).OrderByDescending(e => e.Level.Price).FirstOrDefault()?.Level;
var bidAsk = new BidAsk
{
Id = Symbol,
LiquidityProvider = BrokerId,
Ask = _ask != null?Convert.ToDouble(_ask.Price) : 0,
Bid = _bid != null?Convert.ToDouble(_bid.Price) : 0,
DateTime = DateTime.UtcNow
};
return(bidAsk);
}
private bool TryToBidAsk(JObject p, out BidAsk v)
{
v = null;
JToken bid = p.Property("bid")?.Value;
JToken ask = p.Property("ask")?.Value;
if (bid == null || ask == null)
{
return(false);
}
if (!decimal.TryParse(bid.Value <string>(), System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var v1) ||
!decimal.TryParse(bid.Value <string>(), System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var v2) ||
v1 <= 0m || v2 <= 0m || v1 > v2)
{
return(false);
}
v = new BidAsk(v1, v2);
return(true);
}
public void UpdateQuotesOnBidAsk_handle_add_records_for_registered_symbol()
{
BidAsk bidAskOne = new BidAsk {
Id = SerialIntegerFactory.Make(), Symbol = "RTS-9.13_FT", DateTime = BrokerDateTime.Make(DateTime.Now), Row = 0, NRows = 10, Ask = 150010, AskSize = 300, Bid = 150000, BidSize = 100
};
this.tradingData.Get <ObservableCollection <BidAsk> >().Add(bidAskOne);
double resultBidPrice = storage.GetBidPrice(bidAskOne.Symbol, 0);
double resultBidVolume = storage.GetBidVolume(bidAskOne.Symbol, 0);
double resultOfferPrice = storage.GetOfferPrice(bidAskOne.Symbol, 0);
double resultOfferVolume = storage.GetOfferVolume(bidAskOne.Symbol, 0);
Assert.AreEqual(bidAskOne.Bid, resultBidPrice);
Assert.AreEqual(bidAskOne.BidSize, resultBidVolume);
Assert.AreEqual(bidAskOne.Ask, resultOfferPrice);
Assert.AreEqual(bidAskOne.AskSize, resultOfferVolume);
}
public void HandleBidAsk(BidAsk bidAsk)
{
var chunk = chunks[bidAsk.Asset.Symbol];
var chunkOn = bidAsk.TickOnEst.ToChunkOn();
if (chunk.ChunkOn.HasValue && chunkOn != chunk.ChunkOn)
{
if (skipFirsts.Contains(bidAsk.Asset.Symbol))
{
skipFirsts.Remove(bidAsk.Asset.Symbol);
}
else
{
OnChunk?.Invoke(this, new GenericArgs <Chunk>(chunk));
}
chunk.Clear();
chunk.ChunkOn = chunkOn;
}
chunks[bidAsk.Asset.Symbol].Add(bidAsk);
}
public void EmitMarketDepth(global::OpenQuant.API.Instrument instrument, DateTime time, BidAsk side, OrderBookAction action, double price, int size, int position)
{
MarketDepth marketDepth = new MarketDepth(time, string.Empty, position, global::OpenQuant.API.EnumConverter.Convert(action), global::OpenQuant.API.EnumConverter.Convert(side), price, size);
if (this.NewMarketDepth != null)
{
this.NewMarketDepth(this, new MarketDepthEventArgs(marketDepth, instrument.instrument, this));
}
}
public static void Add(Instrument instrument, DateTime datetime, BidAsk side, OrderBookAction action, int position, double price, int size)
{
DataManager.Add(instrument, new OrderBookUpdate(new MarketDepth(datetime, string.Empty, position, EnumConverter.Convert(action), EnumConverter.Convert(side), price, size)));
}
internal BidAskArgs(BidAsk bidAsk)
{
BidAsk = bidAsk;
}
internal static MDSide Convert(BidAsk side)
{
switch (side)
{
case BidAsk.Bid:
return MDSide.Bid;
case BidAsk.Ask:
return MDSide.Ask;
default:
throw new NotSupportedException(string.Format("BidAsk is not supported - {0}", side));
}
}
protected void EmitNewOrderBookUpdate(Instrument instrument, DateTime time, BidAsk side, OrderBookAction action, double price, int size, int position)
{
this.provider.EmitMarketDepth(instrument, time, side, action, price, size, position);
}
/// <summary>
/// Register order and notify about best price update
/// </summary>
public BidAsk RegisterOrderUpdate(List <OrderBookOrder> updates, Dictionary <string, OrderBookNoSql> updateList, Dictionary <string, OrderBookNoSql> deleteList)
{
var priceUpdated = false;
foreach (var order in updates.Where(e => e.IsActive))
{
var orderLevel = ConvertOrder(order);
if (!_data.TryGetValue(order.OrderId, out var entity))
{
entity = OrderBookNoSql.Create(order.BrokerId, order.Symbol, orderLevel, order.Side);
_data[order.OrderId] = entity;
}
entity.Level = orderLevel;
updateList[entity.Level.OrderId] = entity;
if (order.Side == OrderSide.Sell && (_ask == null || _ask?.Price > order.Price))
{
_ask = entity.Level;
priceUpdated = true;
}
if (order.Side == OrderSide.Buy && (_ask == null || _bid?.Price < order.Price))
{
_bid = entity.Level;
priceUpdated = true;
}
}
foreach (var order in updates.Where(e => !e.IsActive))
{
var orderId = order.OrderId;
var orderLevel = ConvertOrder(order);
if (!_data.TryGetValue(order.OrderId, out var entity))
{
entity = OrderBookNoSql.Create(order.BrokerId, order.Symbol, orderLevel, order.Side);
}
_data.Remove(orderId);
deleteList[orderId] = entity;
if (_ask?.OrderId == orderId)
{
_ask = null;
priceUpdated = true;
}
if (_bid?.OrderId == orderId)
{
_bid = null;
priceUpdated = true;
}
}
if (priceUpdated && _ask == null)
{
_ask = _data.Values.Where(e => e.Side == OrderSide.Sell).OrderBy(e => e.Level.Price).FirstOrDefault()?.Level;
}
if (priceUpdated && _bid == null)
{
_bid = _data.Values.Where(e => e.Side == OrderSide.Buy).OrderByDescending(e => e.Level.Price).FirstOrDefault()?.Level;
}
if (_ask != null && _bid != null && _ask.Price <= _bid.Price)
{
_logger.LogError("NEGATIVE SPREAD {symbol}; Ask: {ask}; Bid: {bid}", Symbol, _ask.Price, _bid.Price);
priceUpdated = false;
}
if (priceUpdated)
{
var updateTs = updates.Max(e => e.Timestamp);
var bidAsk = new BidAsk
{
Id = Symbol,
LiquidityProvider = BrokerId,
Ask = _ask != null?Convert.ToDouble(_ask.Price) : 0,
Bid = _bid != null?Convert.ToDouble(_bid.Price) : 0,
DateTime = updateTs
};
return(bidAsk);
}
return(null);
}
public void EmitMarketDepth(global::OpenQuant.API.Instrument instrument, DateTime time, BidAsk side, OrderBookAction action, double price, int size, int position)
{
MarketDepth marketDepth = new MarketDepth(time, string.Empty, position, global::OpenQuant.API.EnumConverter.Convert(action), global::OpenQuant.API.EnumConverter.Convert(side), price, size);
if (this.NewMarketDepth != null)
{
this.NewMarketDepth(this, new MarketDepthEventArgs(marketDepth, instrument.instrument, this));
}
}
public void HandleBidAsk(BidAsk bidAsk)
{
}
public void EmitMarketDepth(Instrument instrument, DateTime time, BidAsk side, OrderBookAction action, double price, int size, int position)
{
MarketDepth marketDepth = new MarketDepth(time, string.Empty, position, EnumConverter.Convert(action), EnumConverter.Convert(side), price, size);
if (this.NewMarketDepth == null)
return;
this.NewMarketDepth((object) this, new MarketDepthEventArgs(marketDepth, (IFIXInstrument) instrument.instrument, (IMarketDataProvider) this));
}
public static void Add(Instrument instrument, DateTime datetime, BidAsk side, OrderBookAction action, int position, double price, int size)
{
DataManager.Add(instrument, new OrderBookUpdate(new MarketDepth(datetime, string.Empty, position, EnumConverter.Convert(action), EnumConverter.Convert(side), price, size)));
}
protected void EmitNewOrderBookUpdate(Instrument instrument, DateTime time, BidAsk side, OrderBookAction action, double price, int size, int position)
{
this.provider.EmitMarketDepth(instrument, time, side, action, price, size, position);
}
