backtester: Futures handling & FTX Cash and Carry example strategy (#930)

* implements futures functions and GRPC functions on new branch

* lint and test fixes

* Fix uneven split pnl. Adds collateral weight test. docs. New clear func

* Test protection if someone has zero collateral

* Uses string instead of double for accuracy

* Fixes old code panic

* context, match, docs

* Addresses Shazniterinos, var names, expanded tests

* Returns subaccount name, provides USD values when offlinecalc

* Fixes oopsie

* Fixes cool bug which allowed made up subaccount results

* Subaccount override on FTX, subaccount results for collateral

* Strenghten collateral account info checks. Improve FTX test

* English is my first language

* Fixes oopsies

* Adds some conceptual futures order details to track PNL

* Initial design of future order processing in the backtester

* Introduces futures concept for collateral and spot/futures config diffs

* Fixes most tests

* Simple designs for collateral funding pair concept

* Expands interface use so much it hurts

* Implements more collateral interfaces

* Adds liquidation, adds strategy, struggles with Binance

* Attempts at getting FTX to work

* Adds calculatePNL as a wrapper function and adds an `IsFutures` asset check

* Successfully loads backtester with collateral currency

* Fails to really get much going for supporting futures

* Merges master changes

* Fleshes out how FTX processes collateral

* Further FTX collateral workings

* hooks up more ftx collateral and pnl calculations

* more funcs to flesh out handling

* Adds more links, just can't fit the pieces together :(

* Greatly expands futures order processing

* Fleshes out position tracker to also handle asset and exchange +testing

* RM linkedOrderID. rn positioncontroller, unexport

* Successfully tracks futures order positions

* Fails to calculate PNL

* Calculates pnl from orders accurately with exception to flipping orders

* Calculates PNL from orders

* Adds another controller layer to make it ez from orderstore

* Backtester now compiles. Adds test coverage

* labels things add scaling collateral test

* Calculates pnl in line with fees

* Mostly accurate PNL, with exception to appending with diff prices

* Adds locks, adds rpc function

* grpc implementations

* Gracefully handles rpc function

* beautiful tests!

* rejiggles tests to polish

* Finishes FTX testing, adds comments

* Exposes collateral calculations to rpc

* Adds commands and testing for rpcserver.go functions

* Increase testing and fix up backtester code

* Returns cool changes to original branch

* end of day fixes

* Fixing some tests

* Fixing tests 🎉

* Fixes all the tests

* Splits the backtester setup and running into different files

* Merge, minor fixes

* Messing with some strategy updates

* Failed understanding at collateral usage

* Begins the creation of cash and carry strategy

* Adds underlying pair, adds filldependentevent for futures

* Completes fill prerequsite event implementation. Can't short though

* Some bug fixes

* investigating funds

* CAN NOW CREATE A SHORT ORDER

* Minor change in short size

* Fixes for unrealised PNL & collateral rendering

* Fixes lint and tests

* Adds some verbosity

* Updates to pnl calc

* Tracks pnl for short orders, minor update to strategy

* Close and open event based on conditions

* Adds pnl data for currency statistics

* Working through PNL calculation automatically. Now panics

* Adds tracking, is blocked from design

* Work to flesh out closing a position

* vain attempts at tracking zeroing out bugs

* woww, super fun new subloggers 🎉

* Begins attempt at automatically handling contracts and collateral based on direction

* Merge master + fixes

* Investigating issues with pnl and holdings

* Minor pnl fixes

* Fixes future position sizing, needs contract sizing

* Can render pnl results, focussing on funding statistics

* tracking candles for futures, but why not btc

* Improves funding statistics

* Colours and stats

* Fixes collateral and snapshot bugs

* Completes test

* Fixes totals bug

* Fix double buy, expand stats, fixes usd totals, introduce interface

* Begins report formatting and calculations

* Appends pnl to receiving curr. Fixes map[time]. accurate USD

* Improves report output rendering

* PNL stats in report. New tests for futures

* Fixes existing tests before adding new coverage

* Test coverage

* Completes portfolio coverage

* Increase coverage exchange, portfolio. fix size bug. NEW CHART

* WHAT IS GOING ON WITH PNL

* Fixes PNL calculation. Adds ability to skip om futures tracking

* minor commit before merge

* Adds basic liquidation to backtester

* Changes liquidation to order based

* Liquidationnnnnn

* Further fleshes out liquidations

* Completes liquidations in a honorable manner. Adds AppendReasonf

* Beginnings of spot futures gap chart. Needs to link currencies to render difference

* Removes fake liquidation. Adds cool new chart

* Fixes somet tests,allows for zero fee value v nil distinction,New tests

* Some annoying test fixes that took too long

* portfolio coverage

* holding coverage, privatisation funding

* Testwork

* boring tests

* engine coverage

* More backtesting coverage

* Funding, strategy, report test coverage

* Completes coverage of report package

* Documentation, fixes some assumptions on asset errors

* Changes before master merge

* Lint and Tests

* defaults to non-coloured rendering

* Chart rendering

* Fixes surprise non-local-lints

* Niterinos to the extremeos

* Fixes merge problems

* The linter splintered across the glinting plinths

* Many nits addressed. Now sells spot position on final candle

* Adds forgotten coverage

* Adds ability to size futures contracts to match spot positions.

* fixes order sell sizing

* Adds tests to sizing. Fixes charting issue

* clint splintered the linters with flint

* Improves stats, stat rendering

* minifix

* Fixes tests and fee bug

* Merge fixeroos

* Microfixes

* Updates orderPNL on first Correctly utilises fees. Adds committed funds

* New base funcs. New order summary

* Fun test updates

* Fix logo colouring

* Fixes niteroonies

* Fix report

* BAD COMMIT

* Fixes funding issues.Updates default fee rates.Combines cashcarry case

* doc regen

* Now returns err

* Fixes sizing bug issue introduced in PR

* Fixes fun fee/total US value bug

* Fix chart bug. Show log charts with disclaimer

* sellside fee

* fixes fee and slippage view

* Fixed slippage price issue

* Fixes calculation and removes rendering

* Fixes stats and some rendering

* Merge fix

* Fixes merge issues

* go mod tidy, lint updates

* New linter attempt

* Version bump in appveyor and makefile

* Regex filename, config fixes, template h2 fixes

* Removes bad stats.

* neatens config builder. Moves filename generator

* Fixes issue where linter wants to fix my spelling

* Fixes pointers and starts

backtester/data/data.go

@@ -1,6 +1,7 @@
 package data
 
 import (
+	"fmt"
 	"sort"
 	"strings"
 
@@ -37,8 +38,15 @@ func (h *HandlerPerCurrency) GetAllData() map[string]map[asset.Item]map[currency
 }
 
 // GetDataForCurrency returns the Handler for a specific exchange, asset, currency
-func (h *HandlerPerCurrency) GetDataForCurrency(e string, a asset.Item, p currency.Pair) Handler {
-	return h.data[e][a][p]
+func (h *HandlerPerCurrency) GetDataForCurrency(ev common.EventHandler) (Handler, error) {
+	if ev == nil {
+		return nil, common.ErrNilEvent
+	}
+	handler, ok := h.data[ev.GetExchange()][ev.GetAssetType()][ev.Pair()]
+	if !ok {
+		return nil, fmt.Errorf("%s %s %s %w", ev.GetExchange(), ev.GetAssetType(), ev.Pair(), ErrHandlerNotFound)
+	}
+	return handler, nil
 }
 
 // Reset returns the struct to defaults
@@ -98,6 +106,9 @@ func (b *Base) History() []common.DataEventHandler {
 
 // Latest will return latest data event
 func (b *Base) Latest() common.DataEventHandler {
+	if b.latest == nil && len(b.stream) >= b.offset+1 {
+		b.latest = b.stream[b.offset]
+	}
 	return b.latest
 }
 
@@ -107,6 +118,11 @@ func (b *Base) List() []common.DataEventHandler {
 	return b.stream[b.offset:]
 }
 
+// IsLastEvent determines whether the latest event is the last event
+func (b *Base) IsLastEvent() bool {
+	return b.latest != nil && b.latest.GetOffset() == int64(len(b.stream))
+}
+
 // SortStream sorts the stream by timestamp
 func (b *Base) SortStream() {
 	sort.Slice(b.stream, func(i, j int) bool {

backtester/data/data_test.go

@@ -1,10 +1,14 @@
 package data
 
 import (
+	"errors"
 	"testing"
 	"time"
 
 	"github.com/shopspring/decimal"
+	"github.com/thrasher-corp/gocryptotrader/backtester/common"
+	"github.com/thrasher-corp/gocryptotrader/backtester/eventtypes/event"
+	"github.com/thrasher-corp/gocryptotrader/backtester/eventtypes/order"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
@@ -16,32 +20,58 @@ type fakeDataHandler struct {
 	time int
 }
 
+func TestLatest(t *testing.T) {
+	t.Parallel()
+	var d Base
+	d.AppendStream(&fakeDataHandler{time: 1})
+	if latest := d.Latest(); latest != d.stream[d.offset] {
+		t.Error("expected latest to match offset")
+	}
+}
+
 func TestBaseDataFunctions(t *testing.T) {
 	t.Parallel()
 	var d Base
-	if latest := d.Latest(); latest != nil {
-		t.Error("expected nil")
-	}
+
 	d.Next()
 	o := d.Offset()
 	if o != 0 {
 		t.Error("expected 0")
 	}
 	d.AppendStream(nil)
+	if d.IsLastEvent() {
+		t.Error("no")
+	}
 	d.AppendStream(nil)
-	d.AppendStream(nil)
-
-	d.Next()
-	o = d.Offset()
-	if o != 0 {
+	if len(d.stream) != 0 {
 		t.Error("expected 0")
 	}
-	if list := d.List(); list != nil {
-		t.Error("expected nil")
+	d.AppendStream(&fakeDataHandler{time: 1})
+	d.AppendStream(&fakeDataHandler{time: 2})
+	d.AppendStream(&fakeDataHandler{time: 3})
+	d.AppendStream(&fakeDataHandler{time: 4})
+	d.Next()
+
+	d.Next()
+	if list := d.List(); len(list) != 2 {
+		t.Errorf("expected 2 received %v", len(list))
 	}
-	if history := d.History(); history != nil {
-		t.Error("expected nil")
+	d.Next()
+	d.Next()
+	if !d.IsLastEvent() {
+		t.Error("expected last event")
 	}
+	o = d.Offset()
+	if o != 4 {
+		t.Error("expected 4")
+	}
+	if list := d.List(); len(list) != 0 {
+		t.Error("expected 0")
+	}
+	if history := d.History(); len(history) != 4 {
+		t.Errorf("expected 4 received %v", len(history))
+	}
+
 	d.SetStream(nil)
 	if st := d.GetStream(); st != nil {
 		t.Error("expected nil")
@@ -60,55 +90,6 @@ func TestSetup(t *testing.T) {
 	}
 }
 
-func TestStream(t *testing.T) {
-	var d Base
-	var f fakeDataHandler
-
-	// shut up coverage report
-	f.GetOffset()
-	f.SetOffset(1)
-	f.IsEvent()
-	f.Pair()
-	f.GetExchange()
-	f.GetInterval()
-	f.GetAssetType()
-	f.GetReason()
-	f.AppendReason("fake")
-	f.GetClosePrice()
-	f.GetHighPrice()
-	f.GetLowPrice()
-	f.GetOpenPrice()
-
-	d.AppendStream(fakeDataHandler{time: 1})
-	d.AppendStream(fakeDataHandler{time: 4})
-	d.AppendStream(fakeDataHandler{time: 10})
-	d.AppendStream(fakeDataHandler{time: 2})
-	d.AppendStream(fakeDataHandler{time: 20})
-
-	d.SortStream()
-
-	f, ok := d.Next().(fakeDataHandler)
-	if f.time != 1 || !ok {
-		t.Error("expected 1")
-	}
-	f, ok = d.Next().(fakeDataHandler)
-	if f.time != 2 || !ok {
-		t.Error("expected 2")
-	}
-	f, ok = d.Next().(fakeDataHandler)
-	if f.time != 4 || !ok {
-		t.Error("expected 4")
-	}
-	f, ok = d.Next().(fakeDataHandler)
-	if f.time != 10 || !ok {
-		t.Error("expected 10")
-	}
-	f, ok = d.Next().(fakeDataHandler)
-	if f.time != 20 || !ok {
-		t.Error("expected 20")
-	}
-}
-
 func TestSetDataForCurrency(t *testing.T) {
 	t.Parallel()
 	d := HandlerPerCurrency{}
@@ -144,15 +125,45 @@ func TestGetAllData(t *testing.T) {
 func TestGetDataForCurrency(t *testing.T) {
 	t.Parallel()
 	d := HandlerPerCurrency{}
-	exch := testExchange
 	a := asset.Spot
 	p := currency.NewPair(currency.BTC, currency.USDT)
-	d.SetDataForCurrency(exch, a, p, nil)
-	d.SetDataForCurrency(exch, a, currency.NewPair(currency.BTC, currency.DOGE), nil)
-	result := d.GetDataForCurrency(exch, a, p)
+	d.SetDataForCurrency(testExchange, a, p, nil)
+	d.SetDataForCurrency(testExchange, a, currency.NewPair(currency.BTC, currency.DOGE), nil)
+	ev := &order.Order{Base: &event.Base{
+		Exchange:     testExchange,
+		AssetType:    a,
+		CurrencyPair: p,
+	}}
+	result, err := d.GetDataForCurrency(ev)
+	if err != nil {
+		t.Error(err)
+	}
 	if result != nil {
 		t.Error("expected nil")
 	}
+
+	_, err = d.GetDataForCurrency(nil)
+	if !errors.Is(err, common.ErrNilEvent) {
+		t.Errorf("received '%v' expected '%v'", err, common.ErrNilEvent)
+	}
+
+	_, err = d.GetDataForCurrency(&order.Order{Base: &event.Base{
+		Exchange:     "lol",
+		AssetType:    asset.USDTMarginedFutures,
+		CurrencyPair: currency.NewPair(currency.EMB, currency.DOGE),
+	}})
+	if !errors.Is(err, ErrHandlerNotFound) {
+		t.Errorf("received '%v' expected '%v'", err, ErrHandlerNotFound)
+	}
+
+	_, err = d.GetDataForCurrency(&order.Order{Base: &event.Base{
+		Exchange:     testExchange,
+		AssetType:    asset.USDTMarginedFutures,
+		CurrencyPair: currency.NewPair(currency.EMB, currency.DOGE),
+	}})
+	if !errors.Is(err, ErrHandlerNotFound) {
+		t.Errorf("received '%v' expected '%v'", err, ErrHandlerNotFound)
+	}
 }
 
 func TestReset(t *testing.T) {
@@ -170,56 +181,74 @@ func TestReset(t *testing.T) {
 }
 
 // methods that satisfy the common.DataEventHandler interface
-func (t fakeDataHandler) GetOffset() int64 {
-	return 0
+func (f fakeDataHandler) GetOffset() int64 {
+	return 4
 }
 
-func (t fakeDataHandler) SetOffset(int64) {
+func (f fakeDataHandler) SetOffset(int64) {
 }
 
-func (t fakeDataHandler) IsEvent() bool {
+func (f fakeDataHandler) IsEvent() bool {
 	return false
 }
 
-func (t fakeDataHandler) GetTime() time.Time {
-	return time.Now().Add(time.Hour * time.Duration(t.time))
+func (f fakeDataHandler) GetTime() time.Time {
+	return time.Now().Add(time.Hour * time.Duration(f.time))
 }
 
-func (t fakeDataHandler) Pair() currency.Pair {
+func (f fakeDataHandler) Pair() currency.Pair {
 	return currency.NewPair(currency.BTC, currency.USD)
 }
 
-func (t fakeDataHandler) GetExchange() string {
+func (f fakeDataHandler) GetExchange() string {
 	return "fake"
 }
 
-func (t fakeDataHandler) GetInterval() kline.Interval {
+func (f fakeDataHandler) GetInterval() kline.Interval {
 	return kline.Interval(time.Minute)
 }
 
-func (t fakeDataHandler) GetAssetType() asset.Item {
+func (f fakeDataHandler) GetAssetType() asset.Item {
 	return asset.Spot
 }
 
-func (t fakeDataHandler) GetReason() string {
+func (f fakeDataHandler) GetReason() string {
 	return "fake"
 }
 
-func (t fakeDataHandler) AppendReason(string) {
+func (f fakeDataHandler) AppendReason(string) {
 }
 
-func (t fakeDataHandler) GetClosePrice() decimal.Decimal {
+func (f fakeDataHandler) GetClosePrice() decimal.Decimal {
 	return decimal.Zero
 }
 
-func (t fakeDataHandler) GetHighPrice() decimal.Decimal {
+func (f fakeDataHandler) GetHighPrice() decimal.Decimal {
 	return decimal.Zero
 }
 
-func (t fakeDataHandler) GetLowPrice() decimal.Decimal {
+func (f fakeDataHandler) GetLowPrice() decimal.Decimal {
 	return decimal.Zero
 }
 
-func (t fakeDataHandler) GetOpenPrice() decimal.Decimal {
+func (f fakeDataHandler) GetOpenPrice() decimal.Decimal {
 	return decimal.Zero
 }
+
+func (f fakeDataHandler) GetUnderlyingPair() currency.Pair {
+	return f.Pair()
+}
+
+func (f fakeDataHandler) AppendReasonf(s string, i ...interface{}) {}
+
+func (f fakeDataHandler) GetBase() *event.Base {
+	return &event.Base{}
+}
+
+func (f fakeDataHandler) GetConcatReasons() string {
+	return ""
+}
+
+func (f fakeDataHandler) GetReasons() []string {
+	return nil
+}

backtester/data/data_types.go

@@ -1,6 +1,7 @@
 package data
 
 import (
+	"errors"
 	"time"
 
 	"github.com/shopspring/decimal"
@@ -9,6 +10,9 @@ import (
 	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
 )
 
+// ErrHandlerNotFound returned when a handler is not found for specified exchange, asset, pair
+var ErrHandlerNotFound = errors.New("handler not found")
+
 // HandlerPerCurrency stores an event handler per exchange asset pair
 type HandlerPerCurrency struct {
 	data map[string]map[asset.Item]map[currency.Pair]Handler
@@ -19,7 +23,7 @@ type Holder interface {
 	Setup()
 	SetDataForCurrency(string, asset.Item, currency.Pair, Handler)
 	GetAllData() map[string]map[asset.Item]map[currency.Pair]Handler
-	GetDataForCurrency(string, asset.Item, currency.Pair) Handler
+	GetDataForCurrency(ev common.EventHandler) (Handler, error)
 	Reset()
 }
 
@@ -50,6 +54,7 @@ type Streamer interface {
 	History() []common.DataEventHandler
 	Latest() common.DataEventHandler
 	List() []common.DataEventHandler
+	IsLastEvent() bool
 	Offset() int
 
 	StreamOpen() []decimal.Decimal

backtester/data/kline/csv/csv.go

@@ -33,7 +33,7 @@ func LoadData(dataType int64, filepath, exchangeName string, interval time.Durat
 	defer func() {
 		err = csvFile.Close()
 		if err != nil {
-			log.Errorln(log.BackTester, err)
+			log.Errorln(common.Data, err)
 		}
 	}()
 

backtester/data/kline/database/database.go

@@ -38,7 +38,7 @@ func LoadData(startDate, endDate time.Time, interval time.Duration, exchangeName
 		resp.Item = klineItem
 		for i := range klineItem.Candles {
 			if klineItem.Candles[i].ValidationIssues != "" {
-				log.Warnf(log.BackTester, "candle validation issue for %v %v %v: %v", klineItem.Exchange, klineItem.Asset, klineItem.Pair, klineItem.Candles[i].ValidationIssues)
+				log.Warnf(common.Data, "candle validation issue for %v %v %v: %v", klineItem.Exchange, klineItem.Asset, klineItem.Pair, klineItem.Candles[i].ValidationIssues)
 			}
 		}
 	case common.DataTrade:

backtester/data/kline/kline.go

@@ -22,21 +22,22 @@ func (d *DataFromKline) HasDataAtTime(t time.Time) bool {
 
 // Load sets the candle data to the stream for processing
 func (d *DataFromKline) Load() error {
-	d.addedTimes = make(map[time.Time]bool)
+	d.addedTimes = make(map[int64]bool)
 	if len(d.Item.Candles) == 0 {
 		return errNoCandleData
 	}
 
 	klineData := make([]common.DataEventHandler, len(d.Item.Candles))
 	for i := range d.Item.Candles {
-		klineData[i] = &kline.Kline{
-			Base: event.Base{
-				Offset:       int64(i + 1),
-				Exchange:     d.Item.Exchange,
-				Time:         d.Item.Candles[i].Time,
-				Interval:     d.Item.Interval,
-				CurrencyPair: d.Item.Pair,
-				AssetType:    d.Item.Asset,
+		newKline := &kline.Kline{
+			Base: &event.Base{
+				Offset:         int64(i + 1),
+				Exchange:       d.Item.Exchange,
+				Time:           d.Item.Candles[i].Time.UTC(),
+				Interval:       d.Item.Interval,
+				CurrencyPair:   d.Item.Pair,
+				AssetType:      d.Item.Asset,
+				UnderlyingPair: d.Item.UnderlyingPair,
 			},
 			Open:             decimal.NewFromFloat(d.Item.Candles[i].Open),
 			High:             decimal.NewFromFloat(d.Item.Candles[i].High),
@@ -45,7 +46,8 @@ func (d *DataFromKline) Load() error {
 			Volume:           decimal.NewFromFloat(d.Item.Candles[i].Volume),
 			ValidationIssues: d.Item.Candles[i].ValidationIssues,
 		}
-		d.addedTimes[d.Item.Candles[i].Time] = true
+		klineData[i] = newKline
+		d.addedTimes[d.Item.Candles[i].Time.UTC().UnixNano()] = true
 	}
 
 	d.SetStream(klineData)
@@ -56,14 +58,14 @@ func (d *DataFromKline) Load() error {
 // AppendResults adds a candle item to the data stream and sorts it to ensure it is all in order
 func (d *DataFromKline) AppendResults(ki *gctkline.Item) {
 	if d.addedTimes == nil {
-		d.addedTimes = make(map[time.Time]bool)
+		d.addedTimes = make(map[int64]bool)
 	}
 
 	var gctCandles []gctkline.Candle
 	for i := range ki.Candles {
-		if _, ok := d.addedTimes[ki.Candles[i].Time]; !ok {
+		if _, ok := d.addedTimes[ki.Candles[i].Time.UnixNano()]; !ok {
 			gctCandles = append(gctCandles, ki.Candles[i])
-			d.addedTimes[ki.Candles[i].Time] = true
+			d.addedTimes[ki.Candles[i].Time.UnixNano()] = true
 		}
 	}
 
@@ -71,7 +73,7 @@ func (d *DataFromKline) AppendResults(ki *gctkline.Item) {
 	candleTimes := make([]time.Time, len(gctCandles))
 	for i := range gctCandles {
 		klineData[i] = &kline.Kline{
-			Base: event.Base{
+			Base: &event.Base{
 				Offset:       int64(i + 1),
 				Exchange:     ki.Exchange,
 				Time:         gctCandles[i].Time,
@@ -93,7 +95,7 @@ func (d *DataFromKline) AppendResults(ki *gctkline.Item) {
 			d.RangeHolder.Ranges[i].Intervals[j].HasData = true
 		}
 	}
-	log.Debugf(log.BackTester, "appending %v candle intervals: %v", len(gctCandles), candleTimes)
+	log.Debugf(common.Data, "appending %v candle intervals: %v", len(gctCandles), candleTimes)
 	d.AppendStream(klineData...)
 	d.SortStream()
 }
@@ -108,7 +110,7 @@ func (d *DataFromKline) StreamOpen() []decimal.Decimal {
 		if val, ok := s[x].(*kline.Kline); ok {
 			ret[x] = val.Open
 		} else {
-			log.Errorf(log.BackTester, "incorrect data loaded into stream")
+			log.Errorf(common.Data, "incorrect data loaded into stream")
 		}
 	}
 	return ret
@@ -124,7 +126,7 @@ func (d *DataFromKline) StreamHigh() []decimal.Decimal {
 		if val, ok := s[x].(*kline.Kline); ok {
 			ret[x] = val.High
 		} else {
-			log.Errorf(log.BackTester, "incorrect data loaded into stream")
+			log.Errorf(common.Data, "incorrect data loaded into stream")
 		}
 	}
 	return ret
@@ -140,7 +142,7 @@ func (d *DataFromKline) StreamLow() []decimal.Decimal {
 		if val, ok := s[x].(*kline.Kline); ok {
 			ret[x] = val.Low
 		} else {
-			log.Errorf(log.BackTester, "incorrect data loaded into stream")
+			log.Errorf(common.Data, "incorrect data loaded into stream")
 		}
 	}
 	return ret
@@ -156,7 +158,7 @@ func (d *DataFromKline) StreamClose() []decimal.Decimal {
 		if val, ok := s[x].(*kline.Kline); ok {
 			ret[x] = val.Close
 		} else {
-			log.Errorf(log.BackTester, "incorrect data loaded into stream")
+			log.Errorf(common.Data, "incorrect data loaded into stream")
 		}
 	}
 	return ret
@@ -172,7 +174,7 @@ func (d *DataFromKline) StreamVol() []decimal.Decimal {
 		if val, ok := s[x].(*kline.Kline); ok {
 			ret[x] = val.Volume
 		} else {
-			log.Errorf(log.BackTester, "incorrect data loaded into stream")
+			log.Errorf(common.Data, "incorrect data loaded into stream")
 		}
 	}
 	return ret

backtester/data/kline/kline_test.go

@@ -140,7 +140,7 @@ func TestStreamOpen(t *testing.T) {
 	}
 	d.SetStream([]common.DataEventHandler{
 		&kline.Kline{
-			Base: event.Base{
+			Base: &event.Base{
 				Exchange:     exch,
 				Time:         time.Now(),
 				Interval:     gctkline.OneDay,
@@ -171,7 +171,7 @@ func TestStreamVolume(t *testing.T) {
 	}
 	d.SetStream([]common.DataEventHandler{
 		&kline.Kline{
-			Base: event.Base{
+			Base: &event.Base{
 				Exchange:     exch,
 				Time:         time.Now(),
 				Interval:     gctkline.OneDay,
@@ -202,7 +202,7 @@ func TestStreamClose(t *testing.T) {
 	}
 	d.SetStream([]common.DataEventHandler{
 		&kline.Kline{
-			Base: event.Base{
+			Base: &event.Base{
 				Exchange:     exch,
 				Time:         time.Now(),
 				Interval:     gctkline.OneDay,
@@ -233,7 +233,7 @@ func TestStreamHigh(t *testing.T) {
 	}
 	d.SetStream([]common.DataEventHandler{
 		&kline.Kline{
-			Base: event.Base{
+			Base: &event.Base{
 				Exchange:     exch,
 				Time:         time.Now(),
 				Interval:     gctkline.OneDay,
@@ -266,7 +266,7 @@ func TestStreamLow(t *testing.T) {
 	}
 	d.SetStream([]common.DataEventHandler{
 		&kline.Kline{
-			Base: event.Base{
+			Base: &event.Base{
 				Exchange:     exch,
 				Time:         time.Now(),
 				Interval:     gctkline.OneDay,

backtester/data/kline/kline_types.go

@@ -2,7 +2,6 @@ package kline
 
 import (
 	"errors"
-	"time"
 
 	"github.com/thrasher-corp/gocryptotrader/backtester/data"
 	gctkline "github.com/thrasher-corp/gocryptotrader/exchanges/kline"
@@ -14,7 +13,7 @@ var errNoCandleData = errors.New("no candle data provided")
 // It holds candle data for a specified range with helper functions
 type DataFromKline struct {
 	data.Base
-	addedTimes  map[time.Time]bool
+	addedTimes  map[int64]bool
 	Item        gctkline.Item
 	RangeHolder *gctkline.IntervalRangeHolder
 }