public List <MarketCandle> GetKlinesWebsocket(string symbol, KlineInterval interval)
        {
            List <MarketCandle> candles = TickerKLines[symbol];

            candles = AggregateCandlesIntoRequestedTimePeriod(KlineInterval.kline_1m, interval, candles);
            return(candles);
        }
Exemple #2
0
        public static decimal GetDivergence(string coinpair, KlineInterval interval)
        {
            var defaultDivergence = API.config.default_divergence;
            var currentPrice      = DataManager.GetPrice(coinpair);

            return(currentPrice * defaultDivergence * IntervalDivergenceMultiplicator[interval]);
        }
Exemple #3
0
        private object SubscribeCandle(string instrument, string field, int interval)
        {
            var key = instrument + "|" + interval;

            if (SubscribedCandle.ContainsKey(key))
            {
                BinanceStreamKlineData stream;
                if (CandleCache.TryGetValue(key, out stream))
                {
                    return(DecodeCandle(stream, field));
                }
                else
                {
                    return(SubscriptionManager.UninitializedValue);
                }
            }
            else
            {
                KlineInterval klineInterval = (KlineInterval)interval;

                SubscribedCandle.Add(key, true);
                Task.Run(() => socketClient.SubscribeToKlineStream(instrument, klineInterval, (stream) =>
                {
                    CandleCache[key] = stream;
                    CacheCandle(stream, interval);
                }));
                return(SubscriptionManager.UninitializedValue);
            }
        }
Exemple #4
0
        public static Core.Enums.Period ToCoreEquivalent(this KlineInterval period)
        {
            switch (period)
            {
            case KlineInterval.OneDay:
                return(Core.Enums.Period.Day);

            case KlineInterval.FiveMinutes:
                return(Core.Enums.Period.FiveMinutes);

            case KlineInterval.OneHour:
                return(Core.Enums.Period.Hour);

            case KlineInterval.OneMinute:
                return(Core.Enums.Period.Minute);

            case KlineInterval.ThirtyMinutes:
                return(Core.Enums.Period.HalfAnHour);

            case KlineInterval.FourHour:
                return(Core.Enums.Period.FourHours);

            case KlineInterval.TwoHour:
                return(Core.Enums.Period.TwoHours);

            case KlineInterval.FiveteenMinutes:
                return(Core.Enums.Period.QuarterOfAnHour);

            default:
                throw new ArgumentException($"{period} is an unknown value for Period");
            }
        }
Exemple #5
0
        public void Unsubscribe(string symbol, KlineInterval interval)
        {
            var intervalStr = string.Format("kline_{0}", TransferNameConverter.Convert(interval));
            var msg         = new { method = "unsubscribe", topic = intervalStr, symbols = new[] { symbol } };

            _ws.Send(msg);
        }
Exemple #6
0
 public TrendlineIndicator(string coin, KlineInterval interval, int numberOfCandles)
 {
     this.coinPair     = coin;
     this.interval     = interval;
     this.candleNumber = numberOfCandles;
     analyseTimer      = new Timer((obj) => { AnalyseCoin(); }, null, 0, 1000 * 10);
 }
        //-------------------------------------需要慎重的两个函数------开始-------------------
        //
        public async Task <List <KlineInfo> > GetHistoryKlines(
            string symbol,
            KlineInterval interval,
            DateTime start,
            DateTime end,
            int limit = 800)
        {
            long s = new DateTimeOffset(start).ToUnixTimeMilliseconds();
            long e = new DateTimeOffset(end).ToUnixTimeMilliseconds();

            //string path = "/v2/candles/trade:"
            //    + ConvertHelper.ObtainEnumValue(interval)
            //    + ":t" + symbol.ToUpper()
            //    + "/hist?limit=" + limit.ToString()
            //    + "&start=" + s.ToString()
            //    + "&end=" + e.ToString()
            //    + "&sort=1";

            BaseInfo args = GeneratePayload("GetHistoryKlines");

            args.Add("symbol", symbol);
            args.Add("interval", ConvertHelper.ObtainEnumValue(interval));
            args.Add("start", s);
            args.Add("end", e);
            args.Add("limit", limit);

            return(await ProcessAuthenticated <List <KlineInfo> >(args));

            //return await ProcessPublic<List<KlineInfo>>(path);
        }
        /// <summary>
        /// Gets candlestick/kline bars for a symbol. Bars are uniquely identified by their open time.
        /// </summary>
        /// <returns></returns>
        public List <KlinesResponse> GetKlines(string symbol, KlineInterval interval, int limit = 300, long startTime = 0, long endTime = 0)
        {
            //Call specific settings
            string        urlPattern    = "{0}/klines?symbol={1}&interval={2}&limit={3}";
            string        url           = string.Format(urlPattern, _env.HttpsApiAddress, symbol, TransferNameConverter.Convert(interval), limit);
            StringBuilder sbQueryFilter = new StringBuilder();

            if (startTime > 0)
            {
                sbQueryFilter.AppendFormat("&startTime={0}", startTime);
            }
            if (endTime > 0)
            {
                sbQueryFilter.AppendFormat("&endTime={0}", endTime);
            }
            if (sbQueryFilter.Length > 0)
            {
                url = string.Format("{0}{1}", url, sbQueryFilter);
            }
            int callsPerSecondAllowed = 10;

            //Generic items for calls
            var response = GetStringResponse(url, urlPattern, callsPerSecondAllowed);

            //Call specific processing of returned values
            var ret = JsonConvert.DeserializeObject <List <KlinesResponse> >(response);

            return(ret);
        }
        public static IPeriodCode ToPeriodCode(this KlineInterval interval)
        {
            switch (interval)
            {
            case KlineInterval.OneMinute:
                return(PeriodCode.MINUTE);

            case KlineInterval.FiveMinutes:
                return(PeriodCode.FIVE_MINUTES);

            case KlineInterval.FifteenMinutes:
                return(PeriodCode.QUARTER_HOUR);

            case KlineInterval.ThirtyMinutes:
                return(PeriodCode.HALF_HOUR);

            case KlineInterval.OneHour:
                return(PeriodCode.HOUR);

            case KlineInterval.FourHour:
                return(PeriodCode.FOUR_HOUR);

            case KlineInterval.OneDay:
                return(PeriodCode.DAY);

            default:
                throw new Exception($"Not supported perion {interval.ToString()}");
            }
        }
Exemple #10
0
        public void SubscribingToCandleUpdates_Should_TriggerWithCandleUpdate(KlineInterval timeframe)
        {
            // arrange
            var socket = new TestSocket();

            socket.CanConnect = true;
            var client = TestHelpers.CreateSocketClient(socket);

            BitfinexKline[] result  = null;
            var             subTask = client.SpotStreams.SubscribeToKlineUpdatesAsync("tBTCUSD", timeframe, data => result = data.Data.ToArray());

            var subResponse = new CandleSubscriptionResponse()
            {
                Channel   = "candles",
                Event     = "subscribed",
                ChannelId = 1,
                Symbol    = "BTCUSD",
                Key       = "trade:" + JsonConvert.SerializeObject(timeframe, new KlineIntervalConverter(false)) + ":tBTCUSD"
            };

            socket.InvokeMessage(subResponse);
            subTask.Wait(5000);
            BitfinexKline[] expected = new[] { new BitfinexKline() };

            // act
            socket.InvokeMessage($"[1, {JsonConvert.SerializeObject(expected)}]");

            // assert
            Assert.IsTrue(TestHelpers.AreEqual(result[0], expected[0]));
        }
Exemple #11
0
        public void SubscribingToCandleUpdates_Should_SubscribeSuccessfully(KlineInterval timeframe)
        {
            // arrange
            var socket = new TestSocket();

            socket.CanConnect = true;
            var client = TestHelpers.CreateSocketClient(socket, new BitfinexSocketClientOptions()
            {
                LogLevel = LogLevel.Debug
            });

            var subTask = client.SpotStreams.SubscribeToKlineUpdatesAsync("tBTCUSD", timeframe, data => { });

            var subResponse = new CandleSubscriptionResponse()
            {
                Channel   = "candles",
                Event     = "subscribed",
                ChannelId = 1,
                Symbol    = "BTCUSD",
                Key       = "trade:" + JsonConvert.SerializeObject(timeframe, new KlineIntervalConverter(false)) + ":tBTCUSD"
            };

            // act
            socket.InvokeMessage(subResponse);

            subTask.Wait(5000);

            // assert
            Assert.IsTrue(subTask.Result.Success);
        }
Exemple #12
0
 public ResistanceAnalysation(string pair, KlineInterval interval)
 {
     this.coinPair  = pair;
     this.interval  = interval;
     this.lastPrice = DataManager.GetPrice(pair);
     // Update Resistances every 5 Minutes
     this.updateResistanceTimer = new Timer(this.UpdateResistances, null, 0, 5 * 1000);
 }
        /// <summary>
        /// Connect to the Kline WebSocket
        /// </summary>
        /// <param name="symbol"></param>
        /// <param name="interval"></param>
        /// <param name="messageEventHandler"></param>
        /// <returns></returns>
        public Guid ConnectToKlineWebSocket(string symbol, KlineInterval interval, BinanceWebSocketMessageHandler <BinanceKlineData> messageEventHandler)
        {
            Guard.AgainstNullOrEmpty(symbol, nameof(symbol));
            Logger.Debug("Connecting to Kline Web Socket");
            var endpoint = new Uri($"{BaseWebsocketUri}/{symbol.ToLower()}@kline_{EnumExtensions.GetEnumMemberValue(interval)}");

            return(CreateBinanceWebSocket(endpoint, messageEventHandler));
        }
        public CandleData(string coinPair, KlineInterval interval)
        {
            this.coinPair = coinPair;
            this.interval = interval;
            int minutes = Helper.IntervalToMinuteMatrix[interval];

            Update(0);
            this.updateTimer = new Timer(this.Update, null, (int)(60 * 1000 * MinToNextCall(interval)), 60 * 1000 * minutes);
        }
Exemple #15
0
 public CandleJob(string symbol, DateTime start, DateTime end, KlineInterval interval)
 {
     Working  = false;
     Done     = false;
     Symbol   = symbol;
     Start    = start;
     End      = end;
     Interval = interval;
 }
        public async Task <List <KlinesResponse> > GetKlinesAsync(string symbol, KlineInterval interval, int limit = 300, long startTime = 0, long endTime = 0)
        {
            var br = await Task <List <KlinesResponse> > .Run(() =>
            {
                return(GetKlines(symbol, interval, limit, startTime, endTime));
            });

            return(br);
        }
Exemple #17
0
        public static void AddCandleTracking(string pair, KlineInterval interval)
        {
            if (candleDatas.Find(x => x.coinPair == pair && x.interval == interval) != null)
            {
                throw new Exception("Tried to add candle tracking but tracker already exists for " + pair + ".");
            }

            candleDatas.Add(new CandleData(pair, interval));
        }
Exemple #18
0
 public Trendline(decimal m, decimal n, int startpoint, KlineInterval interval, List <TrendPoint> linePoints, int candleDataSize)
 {
     this.movement       = m;
     this.n              = n;
     this.startpoint     = startpoint;
     this.interval       = interval;
     this.linePoints     = linePoints;
     this.candleDataSize = candleDataSize;
 }
 public IndicatorsManager(string coinPair, KlineInterval interval)
 {
     this.coinPair         = coinPair;
     this.interval         = interval;
     resistanceAnalysation = new ResistanceAnalysation(coinPair, interval);
     tli = new TrendlineIndicator(coinPair, interval, 100);
     sma = new SimpleMovingAverage(coinPair, interval, 9, 100);
     vol = new Volume(coinPair, interval, 100);
 }
        public SimpleMovingAverage(string coinPair, KlineInterval interval, int numberOfCandles, int length)
        {
            this.coinPair        = coinPair;
            this.interval        = interval;
            this.numberOfCandles = numberOfCandles;
            this.length          = length;

            getAverages();
        }
Exemple #21
0
        private void AddKline(KlineInterval interval, BinanceKline klineValue)
        {
            klinesDictionary[interval].Add(klineValue);

            if (interval == klineInterval)
            {
                RaisePropertyChangedEvent("Klines");
            }
        }
        public static string Convert(KlineInterval interval)
        {
            var           s  = interval.ToString();
            StringBuilder sb = new StringBuilder();

            sb.Append(s[1]);
            sb.Append(s[0]);
            return(sb.ToString());
        }
Exemple #23
0
 public static int ToSeconds(this KlineInterval interval)
 {
     if (interval == KlineInterval.OneMinute)
     {
         return(1 * 60);
     }
     if (interval == KlineInterval.ThreeMinute)
     {
         return(3 * 60);
     }
     if (interval == KlineInterval.FiveMinute)
     {
         return(5 * 60);
     }
     if (interval == KlineInterval.FiveteenMinute)
     {
         return(15 * 60);
     }
     if (interval == KlineInterval.ThirtyMinute)
     {
         return(30 * 60);
     }
     if (interval == KlineInterval.OneHour)
     {
         return(1 * 60 * 60);
     }
     if (interval == KlineInterval.TwoHour)
     {
         return(2 * 60 * 60);
     }
     if (interval == KlineInterval.FourHour)
     {
         return(4 * 60 * 60);
     }
     if (interval == KlineInterval.SixHour)
     {
         return(6 * 60 * 60);
     }
     if (interval == KlineInterval.TwelfHour)
     {
         return(12 * 60 * 60);
     }
     if (interval == KlineInterval.OneDay)
     {
         return(1 * 24 * 60 * 60);
     }
     if (interval == KlineInterval.ThreeDay)
     {
         return(3 * 24 * 60 * 60);
     }
     if (interval == KlineInterval.OneWeek)
     {
         return(7 * 24 * 60 * 60);
     }
     return(0);
 }
Exemple #24
0
        public void RetrieveKline(Action <CurrentKlineInfo> handler, KlineInterval interval)
        {
            if (_klineSocketId.HasValue)
            {
                AbortKline();
            }

            _klineSocketId = AccessWebSocket.Subscribe(
                _symbol + "@kline_" + ConvertHelper.ObtainEnumValue(interval), handler);
        }
Exemple #25
0
        public static void ForceCandleUpdate(string pair, KlineInterval interval)
        {
            CandleData data = candleDatas.Find(x => x.coinPair == pair && x.interval == interval);

            if (data == null)
            {
                throw new Exception("Tried to update Candle Data for Pair and or Interval that isn't existing.");
            }
            data.Update(null);
        }
Exemple #26
0
        public static CandleData GetCandleDataForPairAndInterval(string pair, KlineInterval interval)
        {
            CandleData data = candleDatas.Find(x => x.coinPair == pair && x.interval == interval);

            if (data == null)
            {
                throw new Exception("Tried to get Candle Data for Pair and or Interval that isn't existing.");
            }

            return(data);
        }
Exemple #27
0
        //
        public async Task <List <Candlestick> > GetCandlesticks(string pair, KlineInterval interval, int?limit = null, long?startTime = null, long?endTime = null)
        {
            var req = new CandlestickRequest()
            {
                Symbol = pair, Interval = interval, Limit = limit, StartTime = startTime, EndTime = endTime
            };

            Console.WriteLine(interval);

            var resp = await _connecter.PublicRequest(req);

            return(JsonConvert.DeserializeObject <List <Candlestick> >(resp.Content, new CustomCandlestickConverter()));
        }
Exemple #28
0
        public static CandleInfo LastCandleInDB(string market, KlineInterval interval)
        {
            var dt = DBHelper.GetDataTable("SELECT * FROM Candles WHERE Symbol='" + market + "' and Interval=" + interval.ToString() + " order by Id desc LIMIT 1");

            if (dt.Rows.Count > 0)
            {
                return(new CandleInfo(dt.Rows[dt.Rows.Count - 1]));
            }
            else
            {
                return(null);
            }
        }
        public async Task Start(string pricepairname = "NEBLBTC", KlineInterval kli = KlineInterval.OneMinute)
        {
            var subResult = await _socketClient.Spot.SubscribeToKlineUpdatesAsync(pricepairname, kli, data =>
            {
                LastKline = data;
                OnKlineData?.Invoke(data);
            });

            if (subResult.Success)
            {
                _subscription = subResult.Data;
            }
        }
Exemple #30
0
        private KlineInterval MapTimeFrame(Timeframe timeFrame)
        {
            var result = new KlineInterval();

            switch (timeFrame)
            {
            case Timeframe.OneMinute:
                result = KlineInterval.OneMinute;
                break;

            case Timeframe.FiveMinute:
                result = KlineInterval.FiveMinutes;
                break;

            case Timeframe.FiveteenMinute:
                result = KlineInterval.FifteenMinutes;
                break;

            case Timeframe.ThirtyMinute:
                result = KlineInterval.ThirtyMinutes;
                break;

            case Timeframe.OneHour:
                result = KlineInterval.OneHour;
                break;

            case Timeframe.SixHour:
                result = KlineInterval.SixHour;
                break;

            case Timeframe.TwelveHour:
                result = KlineInterval.TwelveHour;
                break;

            case Timeframe.OneDay:
                result = KlineInterval.OneDay;
                break;

            case Timeframe.SevenDay:
                result = KlineInterval.OneWeek;
                break;

            case Timeframe.OneMonth:
                result = KlineInterval.OneMonth;
                break;

            default:
                break;
            }
            return(result);
        }