private SlotMachineEngine()
{
this.symbolFactory = new SymbolFactory();
this.messageWriter = new ConsoleMessageWriter();
this.messageReader = new ConsoleMessageReader();
this.player = new Player();
}
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;
}
internal AdsSymbolLoader(IAdsConnection connection, SymbolLoaderSettings settings, IAccessorRawValue accessor, ISession session, SymbolUploadInfo symbolsInfo)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (accessor == null)
{
throw new ArgumentNullException("accessor");
}
if (symbolsInfo == null)
{
throw new ArgumentNullException("symbolsInfo");
}
ISymbolFactory symbolFactory = null;
this._connection = connection;
this._symbolUploadInfo = symbolsInfo;
symbolFactory = (settings.SymbolsLoadMode != SymbolsLoadMode.DynamicTree) ? ((ISymbolFactory) new TwinCAT.Ads.TypeSystem.SymbolFactory(settings.NonCachedArrayElements)) : ((ISymbolFactory) new DynamicSymbolFactory(new TwinCAT.Ads.TypeSystem.SymbolFactory(settings.NonCachedArrayElements), settings.NonCachedArrayElements));
this._settings = settings;
AdsBinder binder = new AdsBinder(this._connection.Address, this, symbolFactory, this.UseVirtualInstances);
this._symbolFactorServices = new SymbolFactoryServices(binder, symbolFactory, accessor, session);
symbolFactory.Initialize(this._symbolFactorServices);
this._rootNamespace = this._connection.Address.ToString();
this._namespaces = new NamespaceCollection();
}
public Client(Bitfinex ex, ISymbolFactory symbolFactory)
{
Exchange = ex;
SymbolFactory = symbolFactory;
RateLimiter = new BitfinexRateLimiter();
}
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 DynamicSymbolFactory(ISymbolFactory inner, bool nonCachedArrayElements)
{
if (inner == null)
{
throw new ArgumentNullException("inner");
}
this.inner = inner;
this.nonCachedArrayElements = nonCachedArrayElements;
this.inner.SetInvalidCharacters(DefaultInvalidChars);
}
public ExchangeTradeStatWorker(
ILoggerFactory loggerFactory,
ISymbolFactory symbolFactory,
IStorageTransactionFactory <HistorianDbContext> storageTransactionFactory,
IMarketRepository marketRepository)
{
LoggerFactory = loggerFactory;
SymbolFactory = symbolFactory;
StorageTransactionFactory = storageTransactionFactory;
MarketRepository = marketRepository;
}
public ExchangeTradeCatchupWorker(
ILoggerFactory loggerFactory,
ISymbolFactory symbolFactory,
IStorageTransactionFactory <HistorianDbContext> storageTransactionFactory,
IExchangeTradeProvider exchangeTradeProvider,
IHistorianRepository historianRepository)
{
LoggerFactory = loggerFactory;
SymbolFactory = symbolFactory;
StorageTransactionFactory = storageTransactionFactory;
ExchangeTradeProvider = exchangeTradeProvider;
HistorianRepository = historianRepository;
}
public SymbolFactoryServices(IBinder binder, ISymbolFactory factory, IAccessorRawValue accessor, ISession session)
{
if (binder == null)
{
throw new ArgumentNullException("binder");
}
if (factory == null)
{
throw new ArgumentNullException("loader");
}
this._binder = binder;
this._valueAccessor = accessor;
this._symbolFactory = factory;
this._session = session;
}
public ExchangeTradeStatAggregateWorker(
ILoggerFactory loggerFactory,
ISymbolFactory symbolFactory,
IStorageTransactionFactory <HistorianDbContext> storageTransactionFactory,
IExchangeTradeStatProvider exchangeTradeStatProvider,
IHistorianRepository historianRepository,
IMarketRepository marketRepository)
{
LoggerFactory = loggerFactory;
SymbolFactory = symbolFactory;
StorageTransactionFactory = storageTransactionFactory;
ExchangeTradeStatProvider = exchangeTradeStatProvider;
HistorianRepository = historianRepository;
MarketRepository = marketRepository;
}
internal override ISymbolCollection OnCreateSubSymbols(ISymbol parentInstance)
{
ISymbolCollection symbols = null;
ArrayType dataType = (ArrayType)base.DataType;
ISymbolFactory symbolFactory = this.FactoryServices.SymbolFactory;
try
{
symbols = symbolFactory.CreateArrayElementInstances(parentInstance, dataType);
}
catch (Exception exception)
{
TwinCAT.Ads.Module.Trace.TraceError(exception);
throw;
}
return(symbols);
}
internal override ISymbolCollection OnCreateSubSymbols(ISymbol parentInstance)
{
IDataType type = ((DataType)base.DataType).ResolveType(DataTypeResolveStrategy.AliasReference);
ISymbolCollection symbols = base.OnCreateSubSymbols(parentInstance);
try
{
ISymbolFactory symbolFactory = this.FactoryServices.SymbolFactory;
if (type != null)
{
DataTypeCategory category = type.Category;
if (category <= DataTypeCategory.Struct)
{
if (category == DataTypeCategory.Array)
{
symbols = symbolFactory.CreateArrayElementInstances(parentInstance, (IArrayType)type);
}
else if (category == DataTypeCategory.Struct)
{
symbols = symbolFactory.CreateFieldInstances(parentInstance, (IStructType)type);
}
}
else if (category != DataTypeCategory.Pointer)
{
if (category == DataTypeCategory.Union)
{
symbols = symbolFactory.CreateFieldInstances(parentInstance, (IUnionType)type);
}
}
else
{
ISymbol item = symbolFactory.CreateReferenceInstance((IPointerType)type, parentInstance);
if (item != null)
{
symbols.Add(item);
}
}
}
}
catch (Exception exception)
{
Module.Trace.TraceError(exception);
}
return(symbols);
}
protected Binder(IInternalSymbolProvider provider, ISymbolFactory symbolFactory, bool useVirtualInstances)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (symbolFactory == null)
{
throw new ArgumentNullException("symbolFactory");
}
if ((provider.SymbolsInternal != null) && (provider.SymbolsInternal.Mode != InstanceCollectionMode.PathHierarchy))
{
throw new ArgumentException($"Symbol provider has to be in Mode: {InstanceCollectionMode.PathHierarchy}", "provider");
}
this._provider = provider;
this._useVirtualInstances = useVirtualInstances;
this._symbolFactory = symbolFactory;
}
internal override ISymbolCollection OnCreateSubSymbols(ISymbol parentInstance)
{
ISymbolCollection symbols = null;
ISymbolFactory symbolFactory = this.FactoryServices.SymbolFactory;
IArrayType arrayType = this.UpdateDynamicType();
base.size = arrayType.Size;
try
{
symbols = symbolFactory.CreateArrayElementInstances(parentInstance, arrayType);
}
catch (Exception exception)
{
Module.Trace.TraceError(exception);
throw;
}
return(symbols);
}
public ExchangeWorker(
ILoggerFactory loggerFactory,
ISymbolFactory symbolFactory,
IHistorianRepository historianRepository,
IExchangeTradeWorker tradeWorker,
IExchangeTradeAggregateWorker tradeAggregateWorker,
IExchangeTradeStatWorker tradeStatWorker,
IExchangeTradeStatAggregateWorker tradeStatAggregateWorker)
{
LoggerFactory = loggerFactory;
SymbolFactory = symbolFactory;
HistorianRepository = historianRepository;
TradeWorker = tradeWorker;
TradeStatWorker = tradeStatWorker;
TradeAggregateWorker = tradeAggregateWorker;
TradeStatAggregateWorker = tradeStatAggregateWorker;
}
public static T2 ChangeType <T, T2>(this Bitfinex exchange, ISymbolFactory symbolFactory, T obj, NameValueCollection query, NameValueCollection additionalData)
{
if (typeof(T2) == typeof(ICollection <MarketTick>))
{
var ticks = obj as List <object[]>;
return((T2)(object)ticks.Select(t => new MarketTick
{
Exchange = exchange.Name,
Epoch = new Epoch(DateTime.UtcNow),
SymbolCode = symbolFactory.Get(exchange.DecodeSymbol(t[0].ToString())[0], exchange.DecodeSymbol(t[0].ToString())[1]).Code,
BuyPrice = Convert.ToDecimal(t[1]),
SellPrice = Convert.ToDecimal(t[3]),
LastPrice = Convert.ToDecimal(t[7])
}).ToList());
}
if (typeof(T2) == typeof(MarketTick))
{
var tick = obj as object[];
var symbolCode = (SymbolCodeEnum)Enum.Parse(typeof(SymbolCodeEnum), additionalData["SymbolCode"]);
return((T2)(object)new MarketTick
{
Exchange = exchange.Name,
Epoch = new Epoch(DateTime.UtcNow),
SymbolCode = symbolCode,
BuyPrice = Convert.ToDecimal(tick[0]),
SellPrice = Convert.ToDecimal(tick[2]),
LastPrice = Convert.ToDecimal(tick[6])
});
}
if (typeof(T2) == typeof(TradeResult))
{
var trades = obj as JArray;
var filter = trades.Count > 0 ? Convert.ToString(trades.Max(t => t[1])) : query["start"];
var symbolCode = (SymbolCodeEnum)Enum.Parse(typeof(SymbolCodeEnum), additionalData["SymbolCode"]);
return((T2)(object)new TradeResult
{
Exchange = exchange.Name,
SymbolCode = symbolCode,
Trades = trades.Select(t => new MarketTrade
{
Exchange = exchange.Name,
SymbolCode = symbolCode,
Epoch = Epoch.FromMilliseconds(Convert.ToInt64(t[1])),
Price = Convert.ToDecimal(t[3]),
Volume = Math.Abs(Convert.ToDecimal(t[2])),
Side = Convert.ToDecimal(t[2]) > 0 ? OrderSideEnum.Buy : OrderSideEnum.Sell,
SourceTradeId = Convert.ToString(t[0])
}).OrderBy(t => t.Epoch.TimestampMilliseconds).ThenBy(t => t.SourceTradeId).ToList(),
Filter = filter
});
}
if (typeof(T2) == typeof(ICollection <ExchangeStats>))
{
var tradeStats = (obj as List <BitfinexMarketStats>);
var statKey = (ExchangeStatsKeyEnum)Enum.Parse(typeof(ExchangeStatsKeyEnum), additionalData["StatKey"]);
var symbolCode = (SymbolCodeEnum)Enum.Parse(typeof(SymbolCodeEnum), additionalData["SymbolCode"]);
return((T2)(object)tradeStats.Select(t => new ExchangeStats
{
Exchange = exchange.Name,
SymbolCode = symbolCode,
StatKey = statKey,
Epoch = Epoch.FromMilliseconds(Convert.ToInt64(t[0])),
Value = Convert.ToDecimal(t[1])
}).ToList());
}
if (typeof(T) == typeof(T2))
{
return((T2)(object)obj);
}
throw new Exception("Invalid type provided - " + typeof(T2));
}
public SlotFactory(ISymbolFactory symbolFactory)
{
this.symbolFactory = symbolFactory;
}
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;
}
internal AdsBinder(AmsAddress imageBaseAddress, IInternalSymbolProvider provider, ISymbolFactory symbolFactory, bool useVirtualInstance) : base(provider, symbolFactory, useVirtualInstance)
{
this._imageBaseAddress = imageBaseAddress;
}
public CoinbasePro(ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory)
{
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
}
protected void SetUp()
{
var currency = new List <ICurrency>();
currency.Add(new Bitcoin());
currency.Add(new Litecoin());
currency.Add(new Ethereum());
currency.Add(new EthereumClassic());
currency.Add(new Ripple());
currency.Add(new Aud());
currency.Add(new Eur());
currency.Add(new Usd());
currency.Add(new Iota());
currency.Add(new Neo());
currency.Add(new Dash());
currency.Add(new Tether());
currency.Add(new StellarLumens());
currency.Add(new BinanceCoin());
currency.Add(new Monero());
currency.Add(new EOS());
currency.Add(new Zcash());
currency.Add(new TRON());
currency.Add(new Qtum());
currency.Add(new Verge());
currency.Add(new OmiseGo());
currency.Add(new NEM());
currency.Add(new Cardano());
currency.Add(new Lisk());
currency.Add(new ICON());
currency.Add(new Stratis());
currency.Add(new BitShares());
currency.Add(new Siacoin());
currency.Add(new AdEx());
currency.Add(new Waves());
currency.Add(new Golem());
currency.Add(new Status());
currency.Add(new DigixDAO());
currency.Add(new Augur());
currency.Add(new Zrx());
currency.Add(new IOStoken());
currency.Add(new Nano());
currency.Add(new BasicAttentionToken());
currency.Add(new Monaco());
currency.Add(new Steem());
currency.Add(new Civic());
currency.Add(new Aelf());
currency.Add(new PowerLedger());
currency.Add(new Poet());
currency.Add(new Cindicator());
currency.Add(new Storj());
currency.Add(new Decentraland());
currency.Add(new Rcoin());
currency.Add(new FunFair());
currency.Add(new Syscoin());
currency.Add(new Ark());
currency.Add(new Enigma());
currency.Add(new Walton());
currency.Add(new Ontology());
currency.Add(new NAVCoin());
currency.Add(new BitcoinDiamond());
currency.Add(new Tierion());
currency.Add(new TimeNewBank());
currency.Add(new district0x());
currency.Add(new Bancor());
currency.Add(new Gas());
currency.Add(new BlockMason());
currency.Add(new NucleusVision());
currency.Add(new Decred());
currency.Add(new Ardor());
currency.Add(new Neblio());
currency.Add(new Viberate());
currency.Add(new RequestNetwork());
currency.Add(new Gifto());
currency.Add(new AppCoins());
currency.Add(new Viacoin());
currency.Add(new Quantstamp());
currency.Add(new ETHLend());
currency.Add(new Komodo());
currency.Add(new SingularDTV());
currency.Add(new ChainLink());
currency.Add(new ZCoin());
currency.Add(new Lunyr());
currency.Add(new Zilliqa());
currency.Add(new PIVX());
currency.Add(new KyberNetwork());
currency.Add(new AirSwap());
currency.Add(new CyberMiles());
currency.Add(new SimpleToken());
currency.Add(new Nebulas());
currency.Add(new VIBE());
currency.Add(new Aion());
currency.Add(new Storm());
currency.Add(new Bluzelle());
currency.Add(new SONM());
currency.Add(new iExecRLC());
currency.Add(new EnjinCoin());
currency.Add(new Eidoo());
currency.Add(new GenesisVision());
currency.Add(new Loopring());
currency.Add(new CoinDash());
currency.Add(new INSEcosystem());
currency.Add(new Everex());
currency.Add(new Groestlcoin());
currency.Add(new RaidenNetworkToken());
currency.Add(new ThetaToken());
currency.Add(new Aeternity());
currency.Add(new Nuls());
currency.Add(new Populous());
currency.Add(new Nexus());
currency.Add(new Ambrosus());
currency.Add(new Aeron());
currency.Add(new ZenCash());
currency.Add(new WaBi());
currency.Add(new Etherparty());
currency.Add(new OpenAnx());
currency.Add(new POANetwork());
currency.Add(new Bread());
currency.Add(new Agrello());
currency.Add(new Monetha());
currency.Add(new Mithril());
currency.Add(new WePower());
currency.Add(new GXShares());
currency.Add(new MoedaLoyaltyPoints());
currency.Add(new Dent());
currency.Add(new Skycoin());
currency.Add(new QLINK());
currency.Add(new SingularityNET());
currency.Add(new RepublicProtocol());
currency.Add(new Selfkey());
currency.Add(new TrueUSD());
currency.Add(new StreamrDATAcoin());
currency.Add(new Polymath());
currency.Add(new PhoenixCoin());
currency.Add(new VeChain());
currency.Add(new Dock());
currency.Add(new GoChain());
currency.Add(new onGsocial());
currency.Add(new PaxosStandardToken());
currency.Add(new HyperCash());
currency.Add(new IoTeX());
currency.Add(new Mainframe());
currency.Add(new LoomNetwork());
currency.Add(new Holo());
currency.Add(new PundiX());
currency.Add(new MalteseLira());
currency.Add(new StableUSD());
currency.Add(new Ravencoin());
currency.Add(new QuarkChain());
currency.Add(new USDC());
currency.Add(new Wanchain());
currency.Add(new Yoyow());
currency.Add(new Ethos());
CurrencyFactory = new CurrencyFactory(currency);
SymbolFactory = new SymbolFactory(CurrencyFactory);
}
public Kraken(ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory)
{
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
}
public Binance(ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory)
{
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
}
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 Bitfinex(ICurrencyFactory currencyFactory, ISymbolFactory symbolFactory)
{
CurrencyFactory = currencyFactory;
SymbolFactory = symbolFactory;
}
public Client(Bitfinex ex, ISymbolFactory symbolFactory)
{
Exchange = ex;
SymbolFactory = symbolFactory;
}
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));
}
internal ArrayElementSymbolCollection(ISymbol arrayInstance, IArrayType arrayType, ISymbolFactory factory)
{
this._arrayInstance = arrayInstance;
this._arrayType = arrayType;
this._symbolFactory = factory;
}
