public Order Convert(TradingPair pair) { return(new Order( Conversion.ToDecimalInvariant(Amount), pair, Id.ToString(), Conversion.ToDecimalInvariant(Price), Type == 0 ? OrderType.Buy : OrderType.Sell, Conversion.ToDateTimeInvariant(Datetime), ExchangeType.BitStamp )); }
/// <summary> /// Scans all trading pairs for a coin to find the best offer /// which meets the criteria specified. /// </summary> /// <param name="onlyOnTheseExchanges"> /// If specified, only consider trades on one of these exchanges /// </param> public static TradingPair FindBestOffer( this Coin quoteCoin, Coin baseCoin, OrderType orderType, ExchangeName[] onlyOnTheseExchanges = null) { TradingPair bestPair = null; decimal? bestValue = null; foreach (TradingPair pair in quoteCoin.allTradingPairs) { if (onlyOnTheseExchanges != null) { // Filter by exchange (optional) for (int i = 0; i < onlyOnTheseExchanges.Length; i++) { if (pair.exchange.exchangeName != onlyOnTheseExchanges[i]) { continue; } } } if (pair.baseCoin != baseCoin) { // Filter by baseCoin continue; } if (pair.isInactive) { // Ignore inactive pairs continue; } decimal value = orderType == OrderType.Buy ? pair.askPriceOrOfferYouCanBuy : pair.bidPriceOrOfferYouCanSell; if (value <= 0) { // No bid/ask to consider here continue; } if (bestValue == null || orderType == OrderType.Buy && value < bestValue.Value || orderType == OrderType.Sell && value > bestValue.Value) { bestValue = value; bestPair = pair; } } return(bestPair); }
public void StandardMovingAverageFourCandles() { const string source = @" TradingPairs: [EOSETH] CandleWidth: 15 "; var config = ParseAlgorithmConfiguration(source); var data = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config); var candles = data.GetCandles(TradingPair.Parse("EOSETH"), 4); var sma = candles.StandardMovingAverage(); Assert.Equal(6.5525M, sma); }
public void ConstructorHappyFlow() { var left = new Currency("BNB"); var right = new Currency("ETH"); int quantityDecimals = 1; int priceDecimals = 2; var pair = new TradingPair(left, right, quantityDecimals, priceDecimals); Assert.Equal(left, pair.Left); Assert.Equal(right, pair.Right); Assert.Equal(quantityDecimals, pair.QuantityDecimals); Assert.Equal(priceDecimals, pair.PriceDecimals); }
public async Task LastTrade() { CrypnosticConfig config = new CrypnosticConfig(exchangeName); monitor = new CrypnosticController(config); await monitor.StartAsync(); TradingPair tradingPair = popularQuoteCoin.GetTradingPair(popularBaseCoin, exchangeName); LastTrade lastTrade = tradingPair.lastTrade; await lastTrade.RefreshAsync(); Assert.IsTrue(lastTrade.price > 0); }
public void AverageTrueRangeSingleEdge() { const string source = @" TradingPairs: [EOSETH] CandleWidth: 25 "; var config = ParseAlgorithmConfiguration(source); var data = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config); var candles = data.GetCandles(TradingPair.Parse("EOSETH"), 2); var atr = candles.AverageTrueRange(); Assert.Equal(2.6M, atr); }
private static OrderUpdate GetSomeOrder(OrderTypes type, decimal setPrice = 0) { return(new OrderUpdate( orderId: 0, tradeId: 0, orderStatus: OrderUpdate.OrderStatus.Filled, orderType: type, createdTimestamp: 0, setPrice: setPrice, side: OrderSide.Buy, pair: TradingPair.Parse("EOSETH"), setQuantity: 0)); }
public Tick Convert(TradingPair pair) { return(new Tick( Conversion.ToDecimalInvariant(ask), Conversion.ToDecimalInvariant(bid), Conversion.ToDecimalInvariant(price), Conversion.ToDecimalInvariant(volume), pair, ExchangeType.Gdax, (long)time.ToUnixTime())); /*{"trade_id":6442532,"price":"372.63","size":"0.31379","bid":"372.54","ask":"372.64","volume":"6866.60379037","time":"2016-02-03T01:05:02.047318Z"}*/ }
/// <summary> /// Initializes a new instance of the <see cref="Startup"/> class. /// Sets configuration. /// </summary> /// <param name="filepath">Location of the configuration file.</param> public Startup(string filepath) { // Download all currencies from Binance TradingPair.Sync(); using (var file = new StreamReader(filepath)) { var configuration = new DeserializerBuilder() .Build() .Deserialize <Configuration>(file); configuration.Bind(); ConfigurationValidator.ValidateConstraintsRecursively(configuration); } }
public void GetCustomCandlesNoPivotThirtyMinutes() { const string source = @" TradingPairs: [EOSETH] CandleWidth: 30 "; var config = ParseAlgorithmConfiguration(source); var data = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config); var candles = data.GetCandles(TradingPair.Parse("EOSETH"), 2); Assert.Equal(5.6M, candles[0].Close); Assert.Equal(5.7M, candles[1].Close); }
/// <inheritdoc/> public override ResponseObject <decimal> GetCurrentPriceLastTrade(TradingPair pair) { var client = _communications.Client; var response = client.GetPrice(pair.ToString()); if (!response.Success) { Logger.LogWarning($"Could not fetch price for {pair} from binance"); return(new ResponseObject <decimal>(ResponseCode.Error)); } return(new ResponseObject <decimal>(ResponseCode.Success, response.Data.Price)); }
public void GetCandlesTimestampIncreasing(int limit) { var candles = _container.DataProvider.GetCandles( TradingPair.Parse("EOSETH"), limit); var increment = (long)TimeSpan.FromMinutes((int)Configuration.Instance.CandleWidth).TotalMilliseconds; var diffs = candles.Pairwise((a, b) => b.OpenTimestamp - a.OpenTimestamp); foreach (var diff in diffs) { Assert.Equal(increment, diff); } }
public BExError Convert(TradingPair pair) { var sb = new StringBuilder(); foreach (var line in error.__all__) { sb.Append(line); } return(new BExError(ExchangeType.BitStamp) { Message = sb.ToString() }); }
static void Main(string[] args) { Console.WriteLine("CryptoSharp Sample"); var adapter = new BittrexAdapter(new BittrexClient()); var tradingPair = new TradingPair("ETH", "BTC"); var ticker = adapter.GetTickerAsync(tradingPair).Result; Console.WriteLine(ticker); Console.ReadKey(); }
public void GetCustomCandlesMultiple() { const string source = @" TradingPairs: [EOSETH] CandleWidth: 15 "; var config = ParseAlgorithmConfiguration(source); var data = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderHappyFlowImplementation>(config); var candles = data.GetCandles(TradingPair.Parse("EOSETH"), 3); Assert.Equal(8.01M, candles[0].Close); Assert.Equal(5.6M, candles[1].Close); Assert.Equal(6.9M, candles[2].Close); }
public void HighestHighIsMaximumOfCandleHighs() { const string source = @" TradingPairs: [EOSETH] CandleWidth: 5 "; var config = ParseAlgorithmConfiguration(source); var data = GetDataProvider <DataProviderGetCandlesImplementation>(config); var pair = TradingPair.Parse("EOSETH"); var candles = data.GetCandles(pair, 1300); var highestHigh = data.GetHighestHigh(pair, 1300); Assert.Equal(candles.Max(x => x.High), highestHigh); }
public void LowestLowIsMaximumOfCandleLows() { const string source = @" TradingPairs: [EOSETH] CandleWidth: 5 "; var config = ParseAlgorithmConfiguration(source); var data = GetDataProvider <DataProviderGetCandlesImplementation>(config); var pair = TradingPair.Parse("EOSETH"); var candles = data.GetCandles(pair, 1300); var lowestLow = data.GetLowestLow(pair, 1300); Assert.Equal(candles.Min(x => x.Low), lowestLow); }
/// <summary> /// Get converted information for all trading pairs /// </summary> /// <param name="service">BuzzexDotNet service</param> /// <returns>Collection of TradingPair objects</returns> public static async Task <List <TradingPair> > GetAllInfoConverted(this IBuzzexDotNet service) { var pairs = await GetAllInfo(service); var tradingPairs = new List <TradingPair>(); foreach (var pair in pairs) { var tradingPair = new TradingPair(pair.Key, pair.Value); tradingPairs.Add(tradingPair); } return(tradingPairs); }
/// <summary> /// Get a certain number of minute candles ordered from present -> past. /// </summary> /// <param name="pair">TradingPair.</param> /// <param name="numberOfCandles">Number of minute candles to request (>0).</param> /// <returns>Array of candles.</returns> public BacktestingCandle[] GetCandles(TradingPair pair, int numberOfCandles) { Guard.Argument(pair).NotNull(nameof(pair)); Guard.Argument(numberOfCandles).NotZero().NotNegative(); var query = HelperMethods.RetryMethod( () => Implementation.GetCustomCandles(pair, numberOfCandles, CandleWidth), _logger, 5, 1000); return(query.Success ? query.Data.Length == numberOfCandles ? query.Data : throw new InvalidExchangeDataException($"Requested {numberOfCandles} candles but received {query.Data.Length}") : throw new ExchangeConnectionException(query.Message)); }
/// <summary> /// Place a sell market order using the full allocation. /// </summary> /// <param name="pair">TradingPair to consider.</param> /// <param name="portion">The portion of funds to use (0 ... 1).</param> /// <returns>ResponseObject with an OrderUpdate.</returns> public OrderUpdate ExecutePartialMarketOrderSell(TradingPair pair, decimal portion) { Guard.Argument(pair).NotNull(nameof(pair)); Guard.Argument(portion).NotZero(nameof(portion)).NotNegative().InRange(0M, 1M); var currency = pair.Left; var balance = _allocationManager.GetAvailableFunds(currency).Free *portion; if (balance == 0.0M) { throw new OutOfFundsException(); } return(ExecuteMarketOrderSell(pair, balance)); }
/// <summary> /// Constructor for service /// </summary> public TradingForexService() { ForexTradingContext forexTradingContext = new ForexTradingContext(); _clients = new Dictionary <ITradingForexClient, KeyValuePair <string, TradingPair> >(); logs = new Queue <string>(); _defaultTradingPair = (from x in forexTradingContext.TraidingPairs select x).FirstOrDefault(); System.Timers.Timer aTimer = new System.Timers.Timer(); aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent); aTimer.Interval = 500; aTimer.Enabled = true; }
/// <summary> /// Place a buy market order given a non base quantity. /// </summary> /// <param name="pair">TradingPair to consider.</param> /// <param name="quantity">Quantity of non base currency.</param> /// <returns>ResponseObject containing an OrderUpdate.</returns> public OrderUpdate ExecuteMarketOrderBuy(TradingPair pair, decimal quantity) { _logger.LogDebug($"Executing buy market order with pair {pair}, quantity {quantity}"); Guard.Argument(pair).NotNull(nameof(pair)); Guard.Argument(quantity).NotZero(nameof(quantity)).NotNegative(); var currency = pair.Right; var priceEstimate = _dataProvider.GetCurrentPriceTopAsk(pair); var proposal = new TradeProposal(pair, new Balance(currency, quantity * priceEstimate, 0)); var result = _allocationManager.QueueTrade(proposal, () => { var orderQuery = HelperMethods.RetryMethod( () => { var attempt = Implementation.ExecuteMarketOrder(pair, OrderSide.Buy, quantity, TradeId); if (attempt.Success) { return(attempt); } _logger.LogInformation($"Retrying with slightly lower quantity"); quantity *= 0.999M; return(new ResponseObject <OrderUpdate>(ResponseCode.Error, attempt.Message)); }, _logger); if (orderQuery.Success) { _openOrders.Add(orderQuery.Data.OrderId, orderQuery.Data); return(WaitForOrderStatus(orderQuery.Data.OrderId, OrderUpdate.OrderStatus.Filled)); } throw new OrderFailedException(orderQuery.Message); }); if (!result.Success) { throw new OrderRefusedException(result.Message); } if (Program.CommandLineArgs.Trading) { _logger.LogInformation($"Executed Market Buy: {JsonConvert.SerializeObject(result)}"); } return(result.Data .IsBuy() .IsMarket() .IsFilled()); }
internal void ParseFromMarketCancelledOrderInvalid(OrderSide side) { var order = new OrderUpdate( orderId: 0, tradeId: 0, orderType: Market, orderStatus: Cancelled, createdTimestamp: 0, setPrice: 0.2M, side: side, pair: TradingPair.Parse("EOSETH"), setQuantity: 100M); Assert.Throws <ArgumentException>(() => TradeExecution.FromOrder(order)); }
/// <inheritdoc/> public override ResponseObject <decimal> GetCurrentPriceTopAsk(TradingPair pair) { var client = _communications.Client; var response = client.GetOrderBook(pair.ToString()); if (!response.Success) { Logger.LogWarning($"Could not fetch top ask for {pair} from binance"); return(new ResponseObject <decimal>(ResponseCode.Error)); } decimal ret = response.Data.Asks.Min(x => x.Price); return(new ResponseObject <decimal>(ResponseCode.Success, ret)); }
/// <inheritdoc /> public override ResponseObject CancelOrder(TradingPair pair, long orderId) { var client = _communications.Client; var query = client.CancelOrder( symbol: pair.ToString(), orderId: orderId, origClientOrderId: null, newClientOrderId: null, receiveWindow: _communications.ReceiveWindow); return(query.Success ? new ResponseObject(ResponseCode.Success) : new ResponseObject(BinanceUtilities.ToInternalError(query.Error.Code), query.Error.Message)); }
public void AverageTrueRangeMultipleEdges() { const string source = @" TradingPairs: [EOSETH] CandleWidth: 15 "; var config = ParseAlgorithmConfiguration(source); var data = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config); var candles = data.GetCandles(TradingPair.Parse("EOSETH"), 4); Logger.LogCritical(JsonConvert.SerializeObject(candles)); var atr = candles.AverageTrueRange(); Assert.Equal(2.2666666666666666666666666667M, atr); }
/// <summary> /// Place a buy market order using the full allocation. /// </summary> /// <param name="pair">TradingPair to consider.</param> /// <param name="portion">The portion of funds to use, (0 ... 1).</param> /// <returns>ResponseObject with an OrderUpdate.</returns> public OrderUpdate ExecutePartialMarketOrderBuy(TradingPair pair, decimal portion) { Guard.Argument(pair).NotNull(); Guard.Argument(portion).NotZero().NotNegative().InRange(0, 1); var currency = pair.Right; var balance = _allocationManager.GetAvailableFunds(currency); var quantity = GetBuyQuantityEstimate(pair, balance.Free) * portion; if (quantity == 0.0M) { throw new OutOfFundsException(); } return(ExecuteMarketOrderBuy(pair, quantity)); }
/// <summary> /// Place a sell stoploss order with the full allocation. /// </summary> /// <param name="pair">Trading pair.</param> /// <param name="price">Price to set the order at.</param> /// <param name="portion">The portion of funds to use.</param> /// <returns>ResponseObject containing an OrderUpdate.</returns> public OrderUpdate PlacePartialStoplossSell(TradingPair pair, decimal price, decimal portion) { Guard.Argument(pair).NotNull(nameof(pair)); Guard.Argument(price).NotZero(nameof(price)).NotNegative(); Guard.Argument(portion).NotZero(nameof(portion)).NotNegative().InRange(0M, 1M); var currency = pair.Left; decimal quantity = _allocationManager.GetAvailableFunds(currency).Free *portion; if (quantity == 0.0M) { throw new OutOfFundsException(); } return(PlaceStoplossSell(pair, quantity, price)); }
public void AddParseEntryOverwrites() { var pre = GetTradingPair("BNB", "ETH", 0, 0); TradingPair.AddParseEntry("BNBETH", pre); var post = GetTradingPair("BNB", "ETH", 1, 1); TradingPair.AddParseEntry("BNBETH", post); var postParse = TradingPair.Parse("BNBETH"); Assert.NotEqual(pre.QuantityDecimals, postParse.QuantityDecimals); Assert.NotEqual(pre.PriceDecimals, postParse.PriceDecimals); }
/// <summary> /// /// </summary> /// <param name="response"></param> /// <returns></returns> private static List <TradingPair> ConvertTradingPairs(List <Dictionary <string, TradingPairBase> > response) { var pairList = new List <TradingPair>(); foreach (var item in response) { foreach (var kvp in item) { var tradingPair = new TradingPair(kvp.Key, kvp.Value); pairList.Add(tradingPair); } } return(pairList); }