feat(feed): add support for Heikin Ashi candle type (#144)

Author: andreimerfu

exchange/binance.go

@@ -23,6 +23,7 @@ type Binance struct {
 	client     *binance.Client
 	assetsInfo map[string]model.AssetInfo
 	userInfo   UserInfo
+	HeikinAshi bool
 
 	APIKey    string
 	APISecret string
@@ -37,6 +38,12 @@ func WithBinanceCredentials(key, secret string) BinanceOption {
 	}
 }
 
+func WithBinanceHeikinAshiCandle() BinanceOption {
+	return func(b *Binance) {
+		b.HeikinAshi = true
+	}
+}
+
 func NewBinance(ctx context.Context, options ...BinanceOption) (*Binance, error) {
 	binance.WebsocketKeepalive = true
 	exchange := &Binance{ctx: ctx}
@@ -457,16 +464,25 @@ func (b *Binance) Position(pair string) (asset, quote float64, err error) {
 func (b *Binance) CandlesSubscription(ctx context.Context, pair, period string) (chan model.Candle, chan error) {
 	ccandle := make(chan model.Candle)
 	cerr := make(chan error)
+	ha := model.NewHeikinAshi()
 
 	go func() {
-		b := &backoff.Backoff{
+		ba := &backoff.Backoff{
 			Min: 100 * time.Millisecond,
 			Max: 1 * time.Second,
 		}
+
 		for {
 			done, _, err := binance.WsKlineServe(pair, period, func(event *binance.WsKlineEvent) {
-				b.Reset()
-				ccandle <- CandleFromWsKline(pair, event.Kline)
+				ba.Reset()
+				candle := CandleFromWsKline(pair, event.Kline)
+
+				if candle.Complete && b.HeikinAshi {
+					candle = candle.ToHeikinAshi(ha)
+				}
+
+				ccandle <- candle
+
 			}, func(err error) {
 				cerr <- err
 			})
@@ -483,7 +499,7 @@ func (b *Binance) CandlesSubscription(ctx context.Context, pair, period string)
 				close(ccandle)
 				return
 			case <-done:
-				time.Sleep(b.Duration())
+				time.Sleep(ba.Duration())
 			}
 		}
 	}()
@@ -494,6 +510,7 @@ func (b *Binance) CandlesSubscription(ctx context.Context, pair, period string)
 func (b *Binance) CandlesByLimit(ctx context.Context, pair, period string, limit int) ([]model.Candle, error) {
 	candles := make([]model.Candle, 0)
 	klineService := b.client.NewKlinesService()
+	ha := model.NewHeikinAshi()
 
 	data, err := klineService.Symbol(pair).
 		Interval(period).
@@ -505,7 +522,13 @@ func (b *Binance) CandlesByLimit(ctx context.Context, pair, period string, limit
 	}
 
 	for _, d := range data {
-		candles = append(candles, CandleFromKline(pair, *d))
+		candle := CandleFromKline(pair, *d)
+
+		if b.HeikinAshi {
+			candle = candle.ToHeikinAshi(ha)
+		}
+
+		candles = append(candles, candle)
 	}
 
 	// discard last candle, because it is incomplete
@@ -517,6 +540,7 @@ func (b *Binance) CandlesByPeriod(ctx context.Context, pair, period string,
 
 	candles := make([]model.Candle, 0)
 	klineService := b.client.NewKlinesService()
+	ha := model.NewHeikinAshi()
 
 	data, err := klineService.Symbol(pair).
 		Interval(period).
@@ -529,7 +553,13 @@ func (b *Binance) CandlesByPeriod(ctx context.Context, pair, period string,
 	}
 
 	for _, d := range data {
-		candles = append(candles, CandleFromKline(pair, *d))
+		candle := CandleFromKline(pair, *d)
+
+		if b.HeikinAshi {
+			candle = candle.ToHeikinAshi(ha)
+		}
+
+		candles = append(candles, candle)
 	}
 
 	return candles, nil

exchange/csvfeed.go

@@ -11,16 +11,16 @@ import (
 	"time"
 
 	"github.com/rodrigo-brito/ninjabot/model"
-
 	"github.com/xhit/go-str2duration/v2"
 )
 
 var ErrInsufficientData = errors.New("insufficient data")
 
 type PairFeed struct {
-	Pair      string
-	File      string
-	Timeframe string
+	Pair       string
+	File       string
+	Timeframe  string
+	HeikinAshi bool
 }
 
 type CSVFeed struct {
@@ -62,6 +62,8 @@ func NewCSVFeed(targetTimeframe string, feeds ...PairFeed) (*CSVFeed, error) {
 		}
 
 		var candles []model.Candle
+		ha := model.NewHeikinAshi()
+
 		for _, line := range csvLines {
 			timestamp, err := strconv.Atoi(line[0])
 			if err != nil {
@@ -100,6 +102,10 @@ func NewCSVFeed(targetTimeframe string, feeds ...PairFeed) (*CSVFeed, error) {
 				return nil, err
 			}
 
+			if feed.HeikinAshi {
+				candle = candle.ToHeikinAshi(ha)
+			}
+
 			candles = append(candles, candle)
 		}
 

model/model.go

@@ -2,6 +2,7 @@ package model
 
 import (
 	"fmt"
+	"sort"
 	"strconv"
 	"time"
 )
@@ -68,6 +69,14 @@ type Candle struct {
 	Complete  bool
 }
 
+type HeikinAshi struct {
+	PreviousHACandle Candle
+}
+
+func NewHeikinAshi() *HeikinAshi {
+	return &HeikinAshi{}
+}
+
 func (c Candle) ToSlice(precision int) []string {
 	return []string{
 		fmt.Sprintf("%d", c.Time.Unix()),
@@ -80,6 +89,23 @@ func (c Candle) ToSlice(precision int) []string {
 	}
 }
 
+func (c Candle) ToHeikinAshi(ha *HeikinAshi) Candle {
+	haCandle := ha.CalculateHeikinAshi(c)
+
+	return Candle{
+		Pair:      c.Pair,
+		Open:      haCandle.Open,
+		High:      haCandle.High,
+		Low:       haCandle.Low,
+		Close:     haCandle.Close,
+		Volume:    c.Volume,
+		Complete:  c.Complete,
+		Time:      c.Time,
+		UpdatedAt: c.UpdatedAt,
+		Trades:    c.Trades,
+	}
+}
+
 func (c Candle) Less(j Item) bool {
 	diff := j.(Candle).Time.Sub(c.Time)
 	if diff < 0 {
@@ -123,3 +149,30 @@ func (a Account) Equity() float64 {
 
 	return total
 }
+
+func (ha *HeikinAshi) CalculateHeikinAshi(c Candle) Candle {
+	var hkCandle Candle
+
+	highValues := []float64{c.High, c.Open, c.Close}
+	sort.Float64s(highValues)
+
+	lowValues := []float64{c.Low, c.Open, c.Close}
+	sort.Float64s(lowValues)
+
+	openValue := ha.PreviousHACandle.Open
+	closeValue := ha.PreviousHACandle.Close
+
+	// First HA candle is calculated using current candle
+	if (ha.PreviousHACandle == Candle{}) {
+		openValue = c.Open
+		closeValue = c.Close
+	}
+
+	hkCandle.Open = (openValue + closeValue) / 2
+	hkCandle.High = highValues[2]
+	hkCandle.Close = (c.Open + c.High + c.Low + c.Close) / 4
+	hkCandle.Low = lowValues[0]
+	ha.PreviousHACandle = hkCandle
+
+	return hkCandle
+}

model/model_test.go

@@ -47,3 +47,58 @@ func TestAccount_Balance(t *testing.T) {
 	require.Equal(t, Balance{}, account.Balance("A"))
 	require.Equal(t, Balance{Tick: "B", Free: 1.1, Lock: 1.3}, account.Balance("B"))
 }
+
+func TestHeikinAshi_CalculateHeikinAshi(t *testing.T) {
+	ha := NewHeikinAshi()
+
+	if (HeikinAshi{}.PreviousHACandle != Candle{}) {
+		t.Errorf("PreviousCandle should be empty")
+	}
+
+	// BTC-USDT weekly candles from Binance from 2017-08-14 to 2017-10-09
+	// First market candles were used to easily test accuracy against
+	// TradingView without having to download all market data.
+	candles := []Candle{
+		{Open: 4261.48, Close: 4086.29, High: 4485.39, Low: 3850.00},
+		{Open: 4069.13, Close: 4310.01, High: 4453.91, Low: 3400.00},
+		{Open: 4310.01, Close: 4509.08, High: 4939.19, Low: 4124.54},
+		{Open: 4505.00, Close: 4130.37, High: 4788.59, Low: 3603.00},
+		{Open: 4153.62, Close: 3699.99, High: 4394.59, Low: 2817.00},
+		{Open: 3690.00, Close: 3660.02, High: 4123.20, Low: 3505.55},
+		{Open: 3660.02, Close: 4378.48, High: 4406.52, Low: 3653.69},
+		{Open: 4400.00, Close: 4640.00, High: 4658.00, Low: 4110.00},
+		{Open: 4640.00, Close: 5709.99, High: 5922.30, Low: 4550.00},
+	}
+
+	var results []Candle
+
+	for _, candle := range candles {
+		haCandle := ha.CalculateHeikinAshi(candle)
+		results = append(results, haCandle)
+	}
+
+	// Expected values taken from TradingView.
+	// Source: Binance BTC-USDT
+	expected := []Candle{
+		{Open: 4173.885, Close: 4170.79, High: 4485.39, Low: 3850},
+		{Open: 4172.3375, Close: 4058.2625000000003, High: 4453.91, Low: 3400},
+		{Open: 4115.3, Close: 4470.705, High: 4939.19, Low: 4124.54},
+		{Open: 4293.0025000000005, Close: 4256.74, High: 4788.59, Low: 3603},
+		{Open: 4274.87125, Close: 3766.2999999999997, High: 4394.59, Low: 2817},
+		{Open: 4020.5856249999997, Close: 3744.6925, High: 4123.2, Low: 3505.55},
+		{Open: 3882.6390625, Close: 4024.6775000000002, High: 4406.52, Low: 3653.69},
+		{Open: 3953.65828125, Close: 4452, High: 4658, Low: 4110},
+		{Open: 4202.829140625, Close: 5205.5725, High: 5922.3, Low: 4550},
+	}
+
+	if len(expected) != len(results) {
+		t.Errorf("Expected %d HA candles. Got %d.", len(expected), len(results))
+	}
+
+	for index, expectedHaCandle := range expected {
+		require.Equal(t, expectedHaCandle.Open, results[index].Open)
+		require.Equal(t, expectedHaCandle.Close, results[index].Close)
+		require.Equal(t, expectedHaCandle.High, results[index].High)
+		require.Equal(t, expectedHaCandle.Low, results[index].Low)
+	}
+}

readme.md

@@ -102,7 +102,7 @@ Chart available at http://localhost:8080
   - [x] CLI to download historical data
   - [x] Plot (Candles + Sell / Buy orders, Indicators)
   - [x] Telegram Controller (Status, Buy, Sell, and Notification)
-
+  - [x] Heikin Ashi candle type support
 
 # Roadmap
   - [ ] Include Web UI Controller