public RepositoryBootstrapper(
IExchangeFactory exchangeFactory,
IIntervalFactory intervalFactory,
ICurrencyFactory currencyFactory,
ISymbolFactory symbolFactory,
IOrderSideFactory orderSideFactory,
IStorageTransactionFactory <HistorianDbContext> storageTransactionFactory,
IHistorianRepository historianRepository,
IExchangeRepository exchangeRepository,
IIntervalRepository intervalRepository,
ICurrencyRepository currencyRepository,
ISymbolRepository symbolRepository,
IOrderSideRepository orderSideRepository)
{
ExchangeFactory = exchangeFactory;
IntervalFactory = intervalFactory;
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
OrderSideFactory = orderSideFactory;
StorageTransactionFactory = storageTransactionFactory;
HistorianRepository = historianRepository;
ExchangeRepository = exchangeRepository;
IntervalRepository = intervalRepository;
CurrencyRepository = currencyRepository;
SymbolRepository = symbolRepository;
OrderSideRepository = orderSideRepository;
}
public Client(Binance exchange, ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory)
{
Exchange = exchange;
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
RateLimiter = new BinanceRateLimiter();
}
public Client(CoinbasePro exchange, ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory)
{
Exchange = exchange;
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
RateLimiter = new CoinbaseProRateLimiter();
}
public static CurrencyService CreateSut(
ILogger <CurrencyService> loggerService = null,
ICurrencyFactory currencyFactory = null)
{
return(new CurrencyService(
loggerService ?? Mock.Of <ILogger <CurrencyService> >(),
currencyFactory ?? Mock.Of <ICurrencyFactory>()));
}
public SymbolFactory(ICurrencyFactory currencyFactory)
{
var currencies = currencyFactory.List();
Symbols = new List <ISymbol>();
foreach (var symbolCodeEnum in Enum.GetValues(typeof(SymbolCodeEnum)))
{
var symbolCode = symbolCodeEnum.ToString();
var tradable = !symbolCode.EndsWith("SHORTS") && !symbolCode.EndsWith("LONGS");
var currencyPair = symbolCode.Replace("SHORTS", "").Replace("LONGS", "");
ICurrency baseCurrency = null;
ICurrency quoteCurrency = null;
var baseCandidates = currencies.Where(c => currencyPair.StartsWith(c.Code.ToString()));
foreach (var baseCandidate in baseCandidates)
{
var len = baseCandidate.Code.ToString().Length;
var quoteCurrencyPair = currencyPair.Substring(len, currencyPair.Length - len);
var quoteCandidate = currencies.Where(c => c.Code.ToString().Equals(quoteCurrencyPair)).FirstOrDefault();
if (quoteCandidate != null)
{
baseCurrency = baseCandidate;
quoteCurrency = quoteCandidate;
break;
}
}
if (baseCurrency != null && quoteCurrency != null)
{
var symbol = new Symbol((SymbolCodeEnum)symbolCodeEnum, baseCurrency.Code, quoteCurrency.Code, tradable);
Symbols.Add(symbol);
}
}
}
public static T2 ChangeType <T, T2>(this Kraken exchange, ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory, NameValueCollection postData, T obj)
{
if (typeof(T) == typeof(KrakenCancelOrderResult))
{
var cancelOrder = obj as KrakenCancelOrderResult;
return((T2)(object)new CancelOrder());
}
if (typeof(T) == typeof(KrakenOrderQuery))
{
var orders = obj as KrakenOrderQuery;
return((T2)(object)orders.Select(kvp => new OrderItem
{
SymbolCode = symbolFactory.Get(exchange.DecodeAssetPair(kvp.Value.Descr.Pair)[0], exchange.DecodeAssetPair(kvp.Value.Descr.Pair)[1]).Code,
Id = kvp.Key,
OrderEpoch = Epoch.FromSeconds((long)kvp.Value.OpenTm),
Side = exchange.GetOrderSide(kvp.Value.Descr.Type),
Type = exchange.GetOrderType(kvp.Value.Descr.OrderType),
State = exchange.GetOrderState(kvp.Value.Status),
Price = exchange.GetOrderType(kvp.Value.Descr.OrderType) == OrderTypeEnum.Limit ? kvp.Value.LimitPrice : kvp.Value.Price,
AvgPrice = kvp.Value.Price,
Fee = kvp.Value.Fee,
Volume = kvp.Value.Volume,
RemainingVolume = kvp.Value.Volume - kvp.Value.VolumeExec
}));
}
if (typeof(T) == typeof(KrakenOpenOrders))
{
var orders = obj as KrakenOpenOrders;
return((T2)(object)orders.Open.Where(o => o.Value.Descr.Pair == postData["pair"]).Select(kvp => new OrderItem
{
SymbolCode = symbolFactory.Get(exchange.DecodeAssetPair(kvp.Value.Descr.Pair)[0], exchange.DecodeAssetPair(kvp.Value.Descr.Pair)[1]).Code,
Id = kvp.Key,
OrderEpoch = Epoch.FromSeconds((long)kvp.Value.OpenTm),
Side = exchange.GetOrderSide(kvp.Value.Descr.Type),
Type = exchange.GetOrderType(kvp.Value.Descr.OrderType),
State = exchange.GetOrderState(kvp.Value.Status),
Price = exchange.GetOrderType(kvp.Value.Descr.OrderType) == OrderTypeEnum.Limit ? kvp.Value.LimitPrice : kvp.Value.Price,
AvgPrice = kvp.Value.Price,
Fee = kvp.Value.Fee,
Volume = kvp.Value.Volume,
RemainingVolume = kvp.Value.Volume - kvp.Value.VolumeExec
}).ToList());
}
if (typeof(T) == typeof(KrakenClosedOrders))
{
var orders = obj as KrakenClosedOrders;
return((T2)(object)orders.Closed.Where(o => o.Value.Descr.Pair == postData["pair"]).Select(kvp => new OrderItem
{
SymbolCode = symbolFactory.Get(exchange.DecodeAssetPair(kvp.Value.Descr.Pair)[0], exchange.DecodeAssetPair(kvp.Value.Descr.Pair)[1]).Code,
Id = kvp.Key,
OrderEpoch = Epoch.FromSeconds((long)kvp.Value.OpenTm),
Side = exchange.GetOrderSide(kvp.Value.Descr.Type),
Type = exchange.GetOrderType(kvp.Value.Descr.OrderType),
State = exchange.GetOrderState(kvp.Value.Status),
Price = exchange.GetOrderType(kvp.Value.Descr.OrderType) == OrderTypeEnum.Limit ? kvp.Value.LimitPrice : kvp.Value.Price,
AvgPrice = kvp.Value.Price,
Fee = kvp.Value.Fee,
Volume = kvp.Value.Volume,
RemainingVolume = kvp.Value.Volume - kvp.Value.VolumeExec
}).ToList());
}
if (typeof(T) == typeof(KrakenAddOrderResult))
{
var order = obj as KrakenAddOrderResult;
return((T2)(object)new CreateOrder
{
Id = order.TxId.First(),
OrderEpoch = Epoch.Now,
SymbolCode = symbolFactory.Get(exchange.DecodeAssetPair(postData["pair"])[0], exchange.DecodeAssetPair(postData["pair"])[1]).Code,
Side = exchange.GetOrderSide(postData["type"]),
Type = exchange.GetOrderType(postData["ordertype"]),
Price = Convert.ToDecimal(postData["price"]),
Volume = Convert.ToDecimal(postData["volume"]),
State = OrderStateEnum.Pending
});
}
if (typeof(T) == typeof(KrakenAccount))
{
var balance = obj as KrakenAccount;
var assets = exchange.Assets;
return((T2)(object)balance.Select(kvp => new AccountBalance
{
CurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, assets[kvp.Key].AltName),
Balance = kvp.Value
}).ToList());
}
if (typeof(T) == typeof(KrakenTradeHistory))
{
var assets = exchange.Assets;
var assetPairs = exchange.AssetPairs;
var trades = obj as KrakenTradeHistory;
return((T2)(object)trades.Trades
.Where(kvp => postData["pair"] == $"{exchange.GetCurrencyCode(exchange.DecodeQuotePair(kvp.Value.Pair)[0])}{exchange.GetCurrencyCode(exchange.DecodeQuotePair(kvp.Value.Pair)[1])}")
.Select(kvp => new TradeItem
{
Exchange = exchange.Name,
SymbolCode = symbolFactory.Get(exchange.GetStandardisedCurrencyCode(currencyFactory, assets[assetPairs[kvp.Value.Pair].Base].AltName), exchange.GetStandardisedCurrencyCode(currencyFactory, assets[assetPairs[kvp.Value.Pair].Quote].AltName)).Code,
Id = kvp.Key,
OrderId = kvp.Value.OrderTxId,
Created = Epoch.FromSeconds(kvp.Value.Time),
Side = exchange.GetOrderSide(kvp.Value.Type),
Price = kvp.Value.Price,
Fee = kvp.Value.Fee,
Volume = kvp.Value.Volume
}).ToList());
}
if (typeof(T) == typeof(KrakenTick))
{
var assets = exchange.Assets;
var assetPairs = exchange.AssetPairs;
var tick = (obj as KrakenTick).First();
return((T2)(object)new MarketTick
{
Exchange = exchange.Name,
SymbolCode = symbolFactory.Get(exchange.GetStandardisedCurrencyCode(currencyFactory, assets[assetPairs[tick.Key].Base].AltName), exchange.GetStandardisedCurrencyCode(currencyFactory, assets[assetPairs[tick.Key].Quote].AltName)).Code,
Epoch = Epoch.Now,
BuyPrice = tick.Value.Ask.First(),
SellPrice = tick.Value.Bid.First(),
LastPrice = tick.Value.Last.First()
});
}
if (typeof(T) == typeof(KrakenTicks))
{
var assets = exchange.Assets;
var assetPairs = exchange.AssetPairs;
var ticks = obj as KrakenTicks;
return((T2)(object)ticks.Select(kvp => new MarketTick
{
Exchange = exchange.Name,
SymbolCode = symbolFactory.Get(exchange.GetStandardisedCurrencyCode(currencyFactory, assets[assetPairs[kvp.Key].Base].AltName), exchange.GetStandardisedCurrencyCode(currencyFactory, assets[assetPairs[kvp.Key].Quote].AltName)).Code,
Epoch = Epoch.Now,
BuyPrice = kvp.Value.Ask.First(),
SellPrice = kvp.Value.Bid.First(),
LastPrice = kvp.Value.Last.First()
}).ToList());
}
if (typeof(T) == typeof(KrakenOrderBook))
{
var book = (obj as KrakenOrderBook).First();
var pair = exchange.DecodeAssetPair(postData["pair"]);
var symbol = symbolFactory.Get(pair[0], pair[1]);
return((T2)(object)new OrderBook
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Ask = book.Value.Asks.Select(a => new OrderBookItem
{
Price = a.ElementAt(0),
AvgPrice = a.ElementAt(0),
Volume = a.ElementAt(1),
OrderTime = Epoch.FromSeconds((long)a.ElementAt(2)).DateTime
}).ToList(),
Bid = book.Value.Bids.Select(a => new OrderBookItem
{
Price = a.ElementAt(0),
Volume = a.ElementAt(1),
OrderTime = Epoch.FromSeconds((long)a.ElementAt(2)).DateTime
}).ToList()
});
}
if (typeof(T) == typeof(KrakenTradeVolume))
{
var tradeVol = (obj as KrakenTradeVolume);
var takerFee = tradeVol.Fees.First().Value.Fee;
return((T2)(object)new TradeFee
{
CurrencyCode = CurrencyCodeEnum.USD,
Taker = takerFee / 100.0m,
Maker = (tradeVol.FeesMaker != null && tradeVol.FeesMaker.Count > 0 ? tradeVol.FeesMaker.First().Value.Fee : takerFee) / 100.0m
});
}
if (typeof(T) == typeof(KrakenTrade <string, List <List <object> > >))
{
var tradeResult = (obj as KrakenTrade <string, List <List <object> > >);
var pair = exchange.DecodeAssetPair(postData["pair"]);
var symbol = symbolFactory.Get(pair[0], pair[1]);
return((T2)(object)new TradeResult
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Filter = Convert.ToString(tradeResult.Last),
Trades = tradeResult.First().Value.Select(t => new MarketTrade
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Epoch = Epoch.FromSeconds(Convert.ToDouble(t[2])),
Price = Convert.ToDecimal(t[0]),
Volume = Convert.ToDecimal(t[1]),
Side = Convert.ToString(t[3]) == "b" ? OrderSideEnum.Buy : OrderSideEnum.Sell
}).ToList()
});
}
if (typeof(T) == typeof(T2))
{
return((T2)(object)obj);
}
throw new Exception("Invalid type provided - " + typeof(T2));
}
protected void SetUp()
{
CurrencyFactory = CommonMock.GetCurrencyFactory();
}
public static T2 ChangeType <T, T2>(this Binance exchange, ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory, NameValueCollection postData, T obj)
{
if (typeof(T) == typeof(ICollection <BinancePriceTicker>))
{
var ticks = new List <MarketTick>();
var priceTicks = obj as ICollection <BinancePriceTicker>;
foreach (var tick in priceTicks)
{
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == tick.Symbol).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
ticks.Add(new MarketTick
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Epoch = Epoch.Now,
LastPrice = tick.Price,
});
}
return((T2)(object)ticks);
}
if (typeof(T) == typeof(ICollection <BinanceOrderBookTicker>))
{
var ticks = new List <MarketTick>();
var bookTicks = (obj as ICollection <BinanceOrderBookTicker>);
foreach (var tick in bookTicks)
{
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == tick.Symbol).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
ticks.Add(new MarketTick
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Epoch = Epoch.Now,
BuyPrice = tick.AskPrice,
SellPrice = tick.BidPrice
});
}
return((T2)(object)ticks);
}
if (typeof(T2) == typeof(TradeResult))
{
var trades = obj as ICollection <Dictionary <string, object> >;
var filter = trades.Count > 0 ? trades.Last()["a"].ToString() : postData["fromId"];
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == postData["symbol"]).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
return((T2)(object)new TradeResult
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Trades = trades.Select(t => new MarketTrade
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Epoch = Epoch.FromMilliseconds(Convert.ToInt64(t["T"])),
Price = Convert.ToDecimal(t["p"]),
Volume = Convert.ToDecimal(t["q"]),
Side = Convert.ToBoolean(t["m"]) ? OrderSideEnum.Sell : OrderSideEnum.Buy,
SourceTradeId = Convert.ToString(t["a"])
}).ToList(),
Filter = filter
});
}
if (typeof(T) == typeof(ICollection <BinanceTradeItem>))
{
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == postData["symbol"]).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
var trades = obj as ICollection <BinanceTradeItem>;
return((T2)(object)trades.Select(t => new TradeItem
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Created = Epoch.FromMilliseconds(t.Time),
Id = t.Id.ToString(),
OrderId = t.OrderId.ToString(),
Fee = t.Commission,
FeeCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, t.CommissionAsset),
Price = t.Price,
Volume = t.Quantity,
Side = t.IsBuyer ? OrderSideEnum.Buy : OrderSideEnum.Sell
}).ToList());
}
if (typeof(T) == typeof(BinanceNewOrder))
{
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == postData["symbol"]).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
var newOrder = obj as BinanceNewOrder;
var orderType = exchange.GetOrderType(newOrder.Type);
var price = orderType == OrderTypeEnum.Limit ? newOrder.Price : newOrder.Fills.Average(f => f.Price);
return((T2)(object)new CreateOrder
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Id = newOrder.OrderId,
Side = exchange.GetOrderSide(newOrder.Side),
Type = orderType,
State = exchange.GetOrderState(newOrder.Status),
OrderEpoch = Epoch.FromMilliseconds(newOrder.TransactTime),
Price = price,
Volume = newOrder.OriginalQuantity
});
}
if (typeof(T) == typeof(ICollection <BinanceOpenOrder>))
{
var binanceSymbol = exchange.Info.Symbols.Where(x => x.Symbol == postData["symbol"]).FirstOrDefault();
var baseCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.BaseAsset);
var quoteCurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, binanceSymbol.QuoteAsset);
var symbol = symbolFactory.Get(baseCurrencyCode, quoteCurrencyCode);
var openOrders = obj as ICollection <BinanceOpenOrder>;
return((T2)(object)openOrders.Select(o => new OrderItem
{
Exchange = exchange.Name,
SymbolCode = symbol.Code,
Id = o.OrderId,
Side = exchange.GetOrderSide(o.Side),
Type = exchange.GetOrderType(o.Type),
State = exchange.GetOrderState(o.Status),
OrderEpoch = Epoch.FromMilliseconds(o.Time),
Price = o.Price,
AvgPrice = o.Price,
Volume = o.OriginalQuantity,
RemainingVolume = o.OriginalQuantity - o.ExecutedQuantity
}).ToList());
}
if (typeof(T) == typeof(BinanceCancelOrder))
{
var cancelOrder = obj as BinanceCancelOrder;
return((T2)(object)new CancelOrder
{
Exchange = exchange.Name,
Id = cancelOrder.OrderId,
Epoch = Epoch.FromMilliseconds(cancelOrder.TransactTime),
State = exchange.GetOrderState(cancelOrder.Status)
});
}
if (typeof(T) == typeof(T2))
{
return((T2)(object)obj);
}
throw new Exception("Invalid type provided - " + typeof(T2));
}
public Client(Kraken ex, ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory)
{
Exchange = ex;
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
}
public CoinbasePro(ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory)
{
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
}
public CurrencyFactoryException(ICurrencyFactory currencyFactory)
{
CurrencyFactory = currencyFactory ?? throw new ArgumentNullException(nameof(currencyFactory));
}
public CurrencyFactoryException(ICurrencyFactory currencyFactory, string?message, Exception?innerException) : base(message, innerException)
{
CurrencyFactory = currencyFactory ?? throw new ArgumentNullException(nameof(currencyFactory));
}
public Bitfinex(ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory)
{
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
}
public static CurrencyCodeEnum GetStandardisedCurrencyCode(this IExchange ex, ICurrencyFactory currencyFactory, string currencyCode)
{
var currency = ex.CurrencyConverter.Where(c => c.AltCurrencyCode == currencyCode).FirstOrDefault();
return(currency != null ? currency.CurrencyCode : currencyFactory.Get(currencyCode).Code);
}
/// <summary>
/// Creates a new currency repository.
/// </summary>
/// <param name="factory">
/// The currency factory.
/// </param>
public CurrencyRepository(ICurrencyFactory factory)
{
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
}
public CurrencyService(
ILogger <CurrencyService> logger,
ICurrencyFactory currencyFactory) =>
(_logger, _currencyFactory) = (logger, currencyFactory);
public static T2 ChangeType <T, T2>(this CoinbasePro exchange, ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory, object requestData, T obj, long?cbBefore)
{
if (typeof(T) == typeof(CoinbaseProCancelOrder))
{
return((T2)(object)new CancelOrder());
}
if (typeof(T) == typeof(CoinbaseProCreateOrderResponse))
{
var order = obj as CoinbaseProCreateOrderResponse;
var symbol = exchange.DecodeProductId(order.ProductId);
return((T2)(object)new CreateOrder
{
Id = order.Id,
SymbolCode = symbol.Code,
Side = exchange.GetOrderSide(order.Side),
Type = exchange.GetOrderType(order.Type),
OrderEpoch = new Epoch(order.CreatedAt.ToUniversalTime()),
Price = order.Price,
Volume = order.Size,
State = exchange.GetOrderState(order.Status)
});
}
if (typeof(T) == typeof(ICollection <CoinbaseProAccount>))
{
var account = obj as ICollection <CoinbaseProAccount>;
return((T2)(object)account.Select(a => new AccountBalance
{
CurrencyCode = exchange.GetStandardisedCurrencyCode(currencyFactory, a.Currency),
Balance = a.Balance,
PendingFunds = a.Hold
}).ToList());
}
if (typeof(T) == typeof(ICollection <CoinbaseProOrder>))
{
var orders = obj as ICollection <CoinbaseProOrder>;
return((T2)(object)orders.Select(o => new OrderItem
{
Id = o.Id,
SymbolCode = exchange.DecodeProductId(o.ProductId).Code,
Side = exchange.GetOrderSide(o.Side),
Type = exchange.GetOrderType(o.Type),
Price = o.Price,
Volume = o.Size,
AvgPrice = o.Price,
RemainingVolume = o.Size - o.FilledSize,
Fee = o.FillFees,
State = exchange.GetOrderState(o.Status)
}).ToList());
}
if (typeof(T) == typeof(CoinbaseProOrderBook))
{
var orderBook = obj as CoinbaseProOrderBook;
var nvc = requestData as NameValueCollection;
return((T2)(object)new OrderBook
{
Exchange = exchange.Name,
SymbolCode = exchange.DecodeProductId(nvc["ProductId"]).Code,
Ask = orderBook.Asks.Select(a => new OrderBookItem
{
Side = OrderSideEnum.Buy,
Price = a.ElementAt(0),
AvgPrice = a.ElementAt(0),
Volume = a.ElementAt(1)
}).ToList(),
Bid = orderBook.Bids.Select(a => new OrderBookItem
{
Side = OrderSideEnum.Sell,
Price = a.ElementAt(0),
AvgPrice = a.ElementAt(0),
Volume = a.ElementAt(1)
}).ToList()
});
}
if (typeof(T) == typeof(CoinbaseProTick))
{
var tick = obj as CoinbaseProTick;
var nvc = requestData as NameValueCollection;
return((T2)(object)new MarketTick
{
Exchange = exchange.Name,
SymbolCode = exchange.DecodeProductId(nvc["ProductId"]).Code,
Epoch = new Epoch(tick.Time.ToUniversalTime()),
BuyPrice = tick.Ask,
SellPrice = tick.Bid,
LastPrice = tick.Price
});
}
if (typeof(T) == typeof(ICollection <CoinbaseProFill>))
{
var trades = obj as ICollection <CoinbaseProFill>;
return((T2)(object)trades.Select(t => new TradeItem
{
Exchange = exchange.Name,
SymbolCode = exchange.DecodeProductId(t.ProductId).Code,
Id = t.TradeId,
OrderId = t.OrderId,
Created = new Epoch(t.CreatedAt.ToUniversalTime()),
Side = exchange.GetOrderSide(t.Side),
Price = t.Price,
Volume = t.Size,
Fee = t.Fee
}).ToList());
}
if (typeof(T) == typeof(ICollection <CoinbaseProMarketTrade>))
{
var trades = obj as ICollection <CoinbaseProMarketTrade>;
var data = (Dictionary <string, object>)requestData;
var symbolCode = (SymbolCodeEnum)data["SymbolCode"];
var limit = (int)data["Limit"];
return((T2)(object)new TradeResult
{
Exchange = exchange.Name,
SymbolCode = symbolCode,
Filter = cbBefore.HasValue ? (cbBefore.Value + limit).ToString() : null,
Trades = trades.Select(t => new MarketTrade
{
Exchange = exchange.Name,
SymbolCode = symbolCode,
Epoch = new Epoch(t.Time),
Price = t.Price,
Volume = t.Size,
Side = exchange.GetOrderSide(t.Side),
SourceTradeId = t.TradeId.ToString()
}).ToList()
});
}
throw new Exception("Invalid type provided - " + typeof(T2));
}
public Binance(ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory)
{
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
}
public Kraken(ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory)
{
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
}
