/// <summary>
/// Equals.
/// </summary>
public bool Equals(AssetPair other)
{
return(string.Equals(Base, other.Base, StringComparison.InvariantCultureIgnoreCase) &&
string.Equals(Quote, other.Quote, StringComparison.InvariantCultureIgnoreCase));
}
public bool IsEqualOrInverted(AssetPair other)
{
return(Equals(other) || IsInverted(other));
}
public bool HasCommonAsset(AssetPair other)
{
return(Base == other.Base || Base == other.Quote || Quote == other.Base || Quote == other.Quote);
}
public bool IsInverted(AssetPair assetPair)
{
return(Base == assetPair.Quote && Quote == assetPair.Base);
}
public static SynthOrderBook FromOrderBooks(OrderBook first, OrderBook second, OrderBook third, AssetPair target)
{
Debug.Assert(first != null);
Debug.Assert(first.AssetPair != null);
Debug.Assert(second != null);
Debug.Assert(second.AssetPair != null);
Debug.Assert(third != null);
Debug.Assert(third.AssetPair != null);
Debug.Assert(target != null);
var result = new SynthOrderBook(target, GetOrdered(new List <OrderBook> {
first, second, third
}, target));
return(result);
}
public static IReadOnlyList <AssetPair> GetChained(IReadOnlyCollection <OrderBook> orderBooks, AssetPair target)
{
Debug.Assert(orderBooks != null);
Debug.Assert(orderBooks.Any());
Debug.Assert(target != null);
var result = new List <AssetPair>();
var @base = target.Base;
var quote = target.Quote;
var first = orderBooks.Single(x => x.AssetPair.ContainsAsset(@base)).AssetPair;
if (first.Quote == @base)
{
first = first.Invert();
}
result.Add(first);
if (orderBooks.Count == 1)
{
Debug.Assert(first.Quote == quote);
return(result);
}
var nextAsset = first.GetOtherAsset(@base);
var second = orderBooks.Single(x => x.AssetPair.ContainsAsset(nextAsset) && !x.AssetPair.IsEqualOrInverted(first)).AssetPair;
if (second.Quote == nextAsset)
{
second = second.Invert();
}
result.Add(second);
if (orderBooks.Count == 2)
{
Debug.Assert(second.Quote == quote);
return(result);
}
nextAsset = second.GetOtherAsset(nextAsset);
var third = orderBooks.Single(x => x.AssetPair.ContainsAsset(nextAsset) && x.AssetPair.ContainsAsset(quote)).AssetPair;
if (third.Quote == nextAsset)
{
third = third.Invert();
}
result.Add(third);
Debug.Assert(third.Quote == quote);
return(result);
}
public static IDictionary <AssetPair, OrderBook> PrepareForEnumeration(IReadOnlyList <OrderBook> orderBooks, AssetPair target)
{
var result = new Dictionary <AssetPair, OrderBook>();
var chainedAssetPairs = GetChained(orderBooks, target);
var orderedOrderBooks = GetOrdered(orderBooks, target);
Debug.Assert(orderBooks.Count == orderedOrderBooks.Count && orderedOrderBooks.Count == chainedAssetPairs.Count);
for (var i = 0; i < orderBooks.Count; i++)
{
result.Add(chainedAssetPairs[i], orderedOrderBooks[i]);
}
return(result);
}
public static IReadOnlyList <SynthOrderBook> GetSynthsFrom2(AssetPair target,
IReadOnlyList <OrderBook> sourceOrderBooks, IReadOnlyList <OrderBook> allOrderBooks)
{
var result = new List <SynthOrderBook>();
// Trying to find base asset in current source's asset pair
var withBaseOrQuoteOrderBooks = sourceOrderBooks.Where(x => x.AssetPair.ContainsAsset(target.Base) ||
x.AssetPair.ContainsAsset(target.Quote)).ToList();
foreach (var withBaseOrQuoteOrderBook in withBaseOrQuoteOrderBooks)
{
var withBaseOrQuoteAssetPair = withBaseOrQuoteOrderBook.AssetPair;
// Get intermediate asset
var intermediateId = withBaseOrQuoteAssetPair.GetOtherAsset(target.Base)
?? withBaseOrQuoteAssetPair.GetOtherAsset(target.Quote);
// 1. If current is target or inverted then just use it
if (intermediateId == target.Base || intermediateId == target.Quote)
{
continue; // The pairs are the same or inverted (it is from 1 order book)
}
// 1. If current is base&intermediate then find quote&intermediate
if (withBaseOrQuoteAssetPair.ContainsAsset(target.Base))
{
var baseAndIntermediate = withBaseOrQuoteOrderBook;
// Trying to find quote/intermediate or intermediate/quote pair (quote&intermediate)
var intermediateQuoteOrderBooks = allOrderBooks
.Where(x => x.AssetPair.ContainsAsset(intermediateId) && x.AssetPair.ContainsAsset(target.Quote))
.ToList();
foreach (var intermediateQuoteOrderBook in intermediateQuoteOrderBooks)
{
if (!baseAndIntermediate.Asks.Any() && !baseAndIntermediate.Bids.Any() ||
!intermediateQuoteOrderBook.Asks.Any() && !intermediateQuoteOrderBook.Bids.Any())
{
continue;
}
var synthOrderBook = FromOrderBooks(baseAndIntermediate, intermediateQuoteOrderBook, target);
result.Add(synthOrderBook);
}
}
// 2. If current is quote&intermediate then find base&intermediate
if (withBaseOrQuoteAssetPair.ContainsAsset(target.Quote))
{
var quoteAndIntermediate = withBaseOrQuoteOrderBook;
// Trying to find base/intermediate or intermediate/base pair (base&intermediate)
var intermediateBaseOrderBooks = allOrderBooks
.Where(x => x.AssetPair.ContainsAsset(intermediateId) && x.AssetPair.ContainsAsset(target.Base))
.ToList();
foreach (var intermediateBaseOrderBook in intermediateBaseOrderBooks)
{
if (!intermediateBaseOrderBook.Asks.Any() && !intermediateBaseOrderBook.Bids.Any() ||
!quoteAndIntermediate.Asks.Any() && !quoteAndIntermediate.Bids.Any())
{
continue;
}
var synthOrderBook = FromOrderBooks(intermediateBaseOrderBook, quoteAndIntermediate, target);
result.Add(synthOrderBook);
}
}
}
return(result);
}
