support futures ticker

Author: adrianceding

src/binance-proxy/handler/handler.go

@@ -10,9 +10,12 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
-func NewHandler(ctx context.Context, class service.Class, enableFakeKline bool) func(w http.ResponseWriter, r *http.Request) {
+func NewHandler(
+	ctx context.Context, class service.Class,
+	enableFakeKline, startTickerWithKline, startOrderbookWithKline bool,
+) func(w http.ResponseWriter, r *http.Request) {
 	handler := &Handler{
-		srv:             service.NewService(ctx, class),
+		srv:             service.NewService(ctx, class, startTickerWithKline, startOrderbookWithKline),
 		class:           class,
 		enableFakeKline: enableFakeKline,
 	}
@@ -38,7 +41,7 @@ func (s *Handler) Router(w http.ResponseWriter, r *http.Request) {
 	case "/api/v3/depth", "/fapi/v1/depth":
 		s.depth(w, r)
 
-	case "/api/v3/ticker/24hr":
+	case "/api/v3/ticker/24hr", "/fapi/v1/ticker/24hr":
 		s.ticker(w, r)
 
 	case "/api/v3/exchangeInfo", "/fapi/v1/exchangeInfo":

src/binance-proxy/main.go

@@ -17,7 +17,7 @@ import (
 
 func startProxy(ctx context.Context, address string, class service.Class) {
 	mux := http.NewServeMux()
-	mux.HandleFunc("/", handler.NewHandler(ctx, class, flagEnableFakeKline))
+	mux.HandleFunc("/", handler.NewHandler(ctx, class, flagEnableFakeKline, flagStartTickerWithKline, flagStartOrderbookWithKline))
 
 	log.Infof("Start %s proxy !Address: %s", class, address)
 	if err := http.ListenAndServe(address, mux); err != nil {
@@ -41,11 +41,15 @@ var flagSpotAddress string
 var flagFuturesAddress string
 var flagDebug bool
 var flagEnableFakeKline bool
+var flagStartTickerWithKline bool
+var flagStartOrderbookWithKline bool
 
 func main() {
 	flag.StringVar(&flagSpotAddress, "s", ":8090", "spot bind address.")
 	flag.StringVar(&flagFuturesAddress, "f", ":8091", "futures bind address.")
 	flag.BoolVar(&flagEnableFakeKline, "fakekline", false, "enable fake kline.")
+	flag.BoolVar(&flagStartTickerWithKline, "at", false, "auto monitor ticker with kline request.")
+	flag.BoolVar(&flagStartOrderbookWithKline, "ao", false, "auto monitor orderbook with kline request.")
 	flag.BoolVar(&flagDebug, "v", false, "print debug log.")
 	flag.Parse()
 

src/binance-proxy/service/service.go

@@ -12,19 +12,28 @@ type Service struct {
 	ctx    context.Context
 	cancel context.CancelFunc
 
+	startTickerWithKline    bool
+	startOrderbookWithKline bool
+
 	class           Class
 	exchangeInfoSrv *ExchangeInfoSrv
 	klinesSrv       sync.Map // map[symbolInterval]*Klines
 	depthSrv        sync.Map // map[symbolInterval]*Depth
 	tickerSrv       sync.Map // map[symbolInterval]*Ticker
 
+	klineIntervalMap sync.Map // map[string]string
+
 	lastGetKlines sync.Map // map[symbolInterval]time.Time
 	lastGetDepth  sync.Map // map[symbolInterval]time.Time
 	lastGetTicker sync.Map // map[symbolInterval]time.Time
 }
 
-func NewService(ctx context.Context, class Class) *Service {
-	s := &Service{class: class}
+func NewService(ctx context.Context, class Class, startTickerWithKline, startOrderbookWithKline bool) *Service {
+	s := &Service{
+		class:                   class,
+		startTickerWithKline:    startTickerWithKline,
+		startOrderbookWithKline: startOrderbookWithKline,
+	}
 	s.ctx, s.cancel = context.WithCancel(ctx)
 	s.exchangeInfoSrv = NewExchangeInfoSrv(s.ctx, NewSymbolInterval(s.class, "", ""))
 	s.exchangeInfoSrv.Start()
@@ -131,6 +140,7 @@ func (s *Service) Klines(symbol, interval string) []*Kline {
 			srv.(*KlinesSrv).Start()
 		}
 	}
+
 	s.lastGetKlines.Store(*si, time.Now())
 
 	return srv.(*KlinesSrv).GetKlines()

src/binance-proxy/service/ticker.go

@@ -8,6 +8,7 @@ import (
 	log "github.com/sirupsen/logrus"
 
 	spot "github.com/adshao/go-binance/v2"
+	futures "github.com/adshao/go-binance/v2/futures"
 )
 
 type TickerSrv struct {
@@ -105,11 +106,19 @@ func (s *TickerSrv) Stop() {
 }
 
 func (s *TickerSrv) connectTickerBook() (doneC, stopC chan struct{}, err error) {
-	return spot.WsBookTickerServe(s.si.Symbol, s.wsHandlerBookTicker, s.errHandler)
+	if s.si.Class == SPOT {
+		return spot.WsBookTickerServe(s.si.Symbol, s.wsHandlerBookTicker, s.errHandler)
+	} else {
+		return futures.WsBookTickerServe(s.si.Symbol, s.wsHandlerBookTickerFutures, s.errHandler)
+	}
 }
 
 func (s *TickerSrv) connectTicker24hr() (doneC, stopC chan struct{}, err error) {
-	return spot.WsMarketStatServe(s.si.Symbol, s.wsHandlerTicker24hr, s.errHandler)
+	if s.si.Class == SPOT {
+		return spot.WsMarketStatServe(s.si.Symbol, s.wsHandlerTicker24hr, s.errHandler)
+	} else {
+		return futures.WsMarketTickerServe(s.si.Symbol, s.wsHandlerTicker24hrFutures, s.errHandler)
+	}
 }
 
 func (s *TickerSrv) GetTicker() *Ticker24hr {
@@ -191,6 +200,47 @@ func (s *TickerSrv) wsHandlerTicker24hr(event *spot.WsMarketStatEvent) {
 	}
 }
 
+func (s *TickerSrv) wsHandlerBookTickerFutures(event *futures.WsBookTickerEvent) {
+	s.rw.Lock()
+	defer s.rw.Unlock()
+
+	s.bookTicker = &BookTicker{
+		Symbol:      event.Symbol,
+		BidPrice:    event.BestBidPrice,
+		BidQuantity: event.BestBidQty,
+		AskPrice:    event.BestAskPrice,
+		AskQuantity: event.BestAskQty,
+	}
+}
+
+func (s *TickerSrv) wsHandlerTicker24hrFutures(event *futures.WsMarketTickerEvent) {
+	s.rw.Lock()
+	defer s.rw.Unlock()
+
+	if s.ticker24hr == nil {
+		defer s.initDone()
+	}
+
+	s.ticker24hr = &Ticker24hr{
+		Symbol:             event.Symbol,
+		PriceChange:        event.PriceChange,
+		PriceChangePercent: event.PriceChangePercent,
+		WeightedAvgPrice:   event.WeightedAvgPrice,
+		LastPrice:          event.ClosePrice,
+		LastQty:            event.CloseQty,
+		OpenPrice:          event.OpenPrice,
+		HighPrice:          event.HighPrice,
+		LowPrice:           event.LowPrice,
+		Volume:             event.BaseVolume,
+		QuoteVolume:        event.QuoteVolume,
+		OpenTime:           event.OpenTime,
+		CloseTime:          event.CloseTime,
+		FirstID:            event.FirstID,
+		LastID:             event.LastID,
+		Count:              event.TradeCount,
+	}
+}
+
 func (s *TickerSrv) errHandler(err error) {
 	log.Errorf("%s.Ticker websocket throw error!Error:%s", s.si, err)
 }