Tests: Use currency.NewBTCUSD and NewBTCUSDT (#1895)

* Tests: Use currency.NewUSD and NewUSDT

Simple refactor to use the provided shortcut methods

* Github: Add CI check to ensure NewPair not used

Add a step to ensure NewPair(BTC, USD*) isn't used

backtester/config/strategyconfig_test.go

@@ -50,7 +50,7 @@ var (
 	initialFunds100000  *decimal.Decimal
 	initialFunds10      *decimal.Decimal
 
-	mainCurrencyPair = currency.NewPair(currency.BTC, currency.USDT)
+	mainCurrencyPair = currency.NewBTCUSDT()
 )
 
 func TestMain(m *testing.M) {

backtester/data/data_test.go

@@ -21,7 +21,7 @@ const (
 	a    = asset.Spot
 )
 
-var p = currency.NewPair(currency.BTC, currency.USD)
+var p = currency.NewBTCUSD()
 
 type fakeEvent struct {
 	secretID int64
@@ -223,7 +223,7 @@ func TestSetStream(t *testing.T) {
 	if len(b.stream) != 0 {
 		t.Errorf("received '%v' expected '%v'", len(b.stream), 0)
 	}
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	err = b.SetStream([]Event{
 		&fakeEvent{
 			Base: &event.Base{
@@ -288,7 +288,7 @@ func TestSetStream(t *testing.T) {
 func TestNext(t *testing.T) {
 	t.Parallel()
 	b := &Base{}
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	err := b.SetStream([]Event{
 		&fakeEvent{
 			Base: &event.Base{
@@ -344,7 +344,7 @@ func TestNext(t *testing.T) {
 func TestHistory(t *testing.T) {
 	t.Parallel()
 	b := &Base{}
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	err := b.SetStream([]Event{
 		&fakeEvent{
 			Base: &event.Base{
@@ -398,7 +398,7 @@ func TestHistory(t *testing.T) {
 func TestLatest(t *testing.T) {
 	t.Parallel()
 	b := &Base{}
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	err := b.SetStream([]Event{
 		&fakeEvent{
 			Base: &event.Base{
@@ -463,7 +463,7 @@ func TestLatest(t *testing.T) {
 func TestList(t *testing.T) {
 	t.Parallel()
 	b := &Base{}
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	err := b.SetStream([]Event{
 		&fakeEvent{
 			Base: &event.Base{
@@ -505,7 +505,7 @@ func TestList(t *testing.T) {
 func TestIsLastEvent(t *testing.T) {
 	t.Parallel()
 	b := &Base{}
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	err := b.SetStream([]Event{
 		&fakeEvent{
 			Base: &event.Base{
@@ -621,7 +621,7 @@ func TestAppendStream(t *testing.T) {
 		t.Errorf("received '%v' expected '%v'", len(b.stream), 0)
 	}
 	tt := time.Now().Add(-time.Hour)
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	e.Exchange = "b"
 	e.AssetType = asset.Spot
 	e.CurrencyPair = cp
@@ -762,7 +762,7 @@ func (f fakeEvent) GetTime() time.Time {
 }
 
 func (f fakeEvent) Pair() currency.Pair {
-	return currency.NewPair(currency.BTC, currency.USD)
+	return currency.NewBTCUSD()
 }
 
 func (f fakeEvent) GetExchange() string {

backtester/data/kline/api/api_test.go

@@ -21,7 +21,7 @@ func TestLoadCandles(t *testing.T) {
 	exch, err := em.NewExchangeByName(testExchange)
 	require.NoError(t, err, "NewExchangeByName must not error")
 	exch.SetDefaults()
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	b := exch.GetBase()
 	b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
 	b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
@@ -48,7 +48,7 @@ func TestLoadTrades(t *testing.T) {
 	exch, err := em.NewExchangeByName(testExchange)
 	require.NoError(t, err, "NewExchangeByName must not error")
 	exch.SetDefaults()
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	b := exch.GetBase()
 	b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
 	b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{

backtester/data/kline/csv/csv_test.go

@@ -16,7 +16,7 @@ const testExchange = "binance"
 func TestLoadDataCandles(t *testing.T) {
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	_, err := LoadData(
 		common.DataCandle,
 		filepath.Join("..", "..", "..", "..", "testdata", "binance_BTCUSDT_24h_2019_01_01_2020_01_01.csv"),
@@ -33,7 +33,7 @@ func TestLoadDataCandles(t *testing.T) {
 func TestLoadDataTrades(t *testing.T) {
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	_, err := LoadData(
 		common.DataTrade,
 		filepath.Join("..", "..", "..", "..", "testdata", "binance_BTCUSDT_24h-trades_2020_11_16.csv"),
@@ -50,7 +50,7 @@ func TestLoadDataTrades(t *testing.T) {
 func TestLoadDataInvalid(t *testing.T) {
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	_, err := LoadData(
 		-1,
 		filepath.Join("..", "..", "..", "..", "testdata", "binance_BTCUSDT_24h-trades_2020_11_16.csv"),

backtester/data/kline/database/database_test.go

@@ -57,7 +57,7 @@ func TestMain(m *testing.M) {
 func TestLoadDataCandles(t *testing.T) {
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	var err error
 	bot := &engine.Engine{}
 	dbConfg := database.Config{
@@ -132,7 +132,7 @@ func TestLoadDataCandles(t *testing.T) {
 func TestLoadDataTrades(t *testing.T) {
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	var err error
 	bot := &engine.Engine{}
 	dbConfg := database.Config{
@@ -200,7 +200,7 @@ func TestLoadDataTrades(t *testing.T) {
 func TestLoadDataInvalid(t *testing.T) {
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	dStart := time.Date(2020, 1, 0, 0, 0, 0, 0, time.UTC)
 	dEnd := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 	_, err := LoadData(dStart, dEnd, gctkline.FifteenMin.Duration(), exch, -1, p, a, false)

backtester/data/kline/kline_test.go

@@ -23,7 +23,7 @@ func TestLoad(t *testing.T) {
 	t.Parallel()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	tt := time.Now()
 	d := DataFromKline{
 		Base: &data.Base{},
@@ -60,7 +60,7 @@ func TestHasDataAtTime(t *testing.T) {
 	dEnd := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := DataFromKline{
 		Base: &data.Base{},
 	}
@@ -148,7 +148,7 @@ func TestHasDataAtTime(t *testing.T) {
 func TestAppend(t *testing.T) {
 	t.Parallel()
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	tt1 := time.Date(2020, 1, 0, 0, 0, 0, 0, time.UTC)
 	tt2 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 	d := DataFromKline{
@@ -211,7 +211,7 @@ func TestStreamOpen(t *testing.T) {
 	t.Parallel()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := DataFromKline{
 		Base: &data.Base{},
 	}
@@ -258,7 +258,7 @@ func TestStreamVolume(t *testing.T) {
 	t.Parallel()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := DataFromKline{
 		Base: &data.Base{},
 	}
@@ -305,7 +305,7 @@ func TestStreamClose(t *testing.T) {
 	t.Parallel()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := DataFromKline{
 		Base: &data.Base{},
 	}
@@ -353,7 +353,7 @@ func TestStreamHigh(t *testing.T) {
 	t.Parallel()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := DataFromKline{
 		Base: &data.Base{},
 	}
@@ -401,7 +401,7 @@ func TestStreamLow(t *testing.T) {
 	t.Parallel()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := DataFromKline{
 		Base:        &data.Base{},
 		RangeHolder: &gctkline.IntervalRangeHolder{},

backtester/data/kline/live/live_test.go

@@ -18,7 +18,7 @@ const testExchange = "okx"
 func TestLoadCandles(t *testing.T) {
 	t.Parallel()
 	interval := gctkline.OneHour
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	a := asset.Spot
 	em := engine.NewExchangeManager()
 	exch, err := em.NewExchangeByName(testExchange)
@@ -44,7 +44,7 @@ func TestLoadCandles(t *testing.T) {
 func TestLoadTrades(t *testing.T) {
 	t.Parallel()
 	interval := gctkline.OneMin
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	a := asset.Spot
 	em := engine.NewExchangeManager()
 	exch, err := em.NewExchangeByName(testExchange)

backtester/engine/backtest_test.go

@@ -142,7 +142,7 @@ func TestLoadDataAPI(t *testing.T) {
 	bt := BackTest{
 		Reports: &report.Data{},
 	}
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	cfg := &config.Config{
 		CurrencySettings: []config.CurrencySettings{
 			{
@@ -197,7 +197,7 @@ func TestLoadDataCSV(t *testing.T) {
 	bt := BackTest{
 		Reports: &report.Data{},
 	}
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	cfg := &config.Config{
 		CurrencySettings: []config.CurrencySettings{
 			{
@@ -255,7 +255,7 @@ func TestLoadDataDatabase(t *testing.T) {
 		Reports:  &report.Data{},
 		shutdown: make(chan struct{}),
 	}
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	cfg := &config.Config{
 		CurrencySettings: []config.CurrencySettings{
 			{
@@ -329,7 +329,7 @@ func TestLoadDataLive(t *testing.T) {
 		shutdown:        make(chan struct{}),
 	}
 
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	cfg := &config.Config{
 		CurrencySettings: []config.CurrencySettings{
 			{
@@ -445,7 +445,7 @@ func TestReset(t *testing.T) {
 func TestFullCycle(t *testing.T) {
 	t.Parallel()
 	ex := testExchange
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	a := asset.Spot
 	tt := time.Now()
 
@@ -579,7 +579,7 @@ func TestStop(t *testing.T) {
 func TestFullCycleMulti(t *testing.T) {
 	t.Parallel()
 	ex := testExchange
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	a := asset.Spot
 	tt := time.Now()
 
@@ -720,7 +720,7 @@ func TestTriggerLiquidationsForExchange(t *testing.T) {
 		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	a := asset.USDTMarginedFutures
 	expectedError = gctcommon.ErrNilPointer
 	ev := &evkline.Kline{
@@ -813,7 +813,7 @@ func TestUpdateStatsForDataEvent(t *testing.T) {
 		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	a := asset.Futures
 	ev := &evkline.Kline{
 		Base: &event.Base{
@@ -891,7 +891,7 @@ func TestProcessSignalEvent(t *testing.T) {
 		EventQueue: &eventholder.Holder{},
 		shutdown:   make(chan struct{}),
 	}
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	a := asset.USDTMarginedFutures
 	de := &evkline.Kline{
 		Base: &event.Base{
@@ -959,7 +959,7 @@ func TestProcessOrderEvent(t *testing.T) {
 		DataHolder: &data.HandlerHolder{},
 		shutdown:   make(chan struct{}),
 	}
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	a := asset.USDTMarginedFutures
 	de := &evkline.Kline{
 		Base: &event.Base{
@@ -1080,7 +1080,7 @@ func TestProcessFillEvent(t *testing.T) {
 		DataHolder: &data.HandlerHolder{},
 		shutdown:   make(chan struct{}),
 	}
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	a := asset.Futures
 	tt := time.Now()
 	de := &evkline.Kline{
@@ -1193,7 +1193,7 @@ func TestProcessFuturesFillEvent(t *testing.T) {
 		DataHolder: &data.HandlerHolder{},
 		shutdown:   make(chan struct{}),
 	}
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	a := asset.Futures
 	de := &evkline.Kline{
 		Base: &event.Base{
@@ -1347,7 +1347,7 @@ func TestCloseAllPositions(t *testing.T) {
 	dc.dataHolder = bt.DataHolder
 	dc.report = &report.Data{}
 	dc.funding = bt.Funding
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	dc.sourcesToCheck = append(dc.sourcesToCheck, &liveDataSourceDataHandler{
 		exchange:                  &binance.Binance{},
 		exchangeName:              testExchange,
@@ -1427,7 +1427,7 @@ func TestRunLive(t *testing.T) {
 		funding:           bt.Funding,
 	}
 	bt.LiveDataHandler = dc
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	i := &gctkline.Item{
 		Pair:           cp,
 		UnderlyingPair: cp,
@@ -1596,7 +1596,7 @@ func TestGetFees(t *testing.T) {
 	_, _, err = getFees(t.Context(), f, currency.EMPTYPAIR)
 	assert.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
 
-	maker, taker, err := getFees(t.Context(), f, currency.NewPair(currency.BTC, currency.USDT))
+	maker, taker, err := getFees(t.Context(), f, currency.NewBTCUSDT())
 	assert.NoError(t, err, "getFees should not error")
 	assert.NotZero(t, maker, "getFees should return a non-zero maker fee")
 	assert.NotZero(t, taker, "getFees should return a non-zero taker fee")
@@ -1914,7 +1914,7 @@ func TestProcessSingleDataEvent(t *testing.T) {
 	if !errors.Is(err, common.ErrNilEvent) {
 		t.Errorf("received '%v' expected '%v'", err, common.ErrNilEvent)
 	}
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	a := asset.Spot
 	ev := &evkline.Kline{
 		Base: &event.Base{

backtester/engine/fakeinterfaces_test.go

@@ -167,7 +167,7 @@ func (f fakeDataHolder) SetDataForCurrency(string, asset.Item, currency.Pair, da
 }
 
 func (f fakeDataHolder) GetAllData() ([]data.Handler, error) {
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	return []data.Handler{
 		&kline.DataFromKline{
 			Base: &data.Base{},
@@ -321,8 +321,8 @@ func (f fakeStrat) CloseAllPositions([]holdings.Holding, []data.Event) ([]signal
 				Exchange:       testExchange,
 				Time:           time.Now(),
 				Interval:       gctkline.FifteenSecond,
-				CurrencyPair:   currency.NewPair(currency.BTC, currency.USD),
-				UnderlyingPair: currency.NewPair(currency.BTC, currency.USD),
+				CurrencyPair:   currency.NewBTCUSD(),
+				UnderlyingPair: currency.NewBTCUSD(),
 				AssetType:      asset.Spot,
 			},
 			OpenPrice:  leet,

backtester/engine/live_test.go

@@ -281,7 +281,7 @@ func TestAppendDataSource(t *testing.T) {
 		t.Errorf("received '%v' expected '%v'", err, currency.ErrCurrencyPairEmpty)
 	}
 
-	setup.pair = currency.NewPair(currency.BTC, currency.USDT)
+	setup.pair = currency.NewBTCUSDT()
 	err = dataHandler.AppendDataSource(setup)
 	if !errors.Is(err, kline.ErrInvalidInterval) {
 		t.Errorf("received '%v' expected '%v'", err, kline.ErrInvalidInterval)
@@ -384,7 +384,7 @@ func TestLoadCandleData(t *testing.T) {
 
 	exch := &binanceus.Binanceus{}
 	exch.SetDefaults()
-	cp := currency.NewPair(currency.BTC, currency.USDT).Format(
+	cp := currency.NewBTCUSDT().Format(
 		currency.PairFormat{
 			Uppercase: true,
 		})

backtester/eventhandlers/exchange/exchange_test.go

@@ -134,18 +134,18 @@ func TestSetCurrency(t *testing.T) {
 	cs := &Settings{
 		Exchange:      f,
 		UseRealOrders: true,
-		Pair:          currency.NewPair(currency.BTC, currency.USDT),
+		Pair:          currency.NewBTCUSDT(),
 		Asset:         asset.Spot,
 	}
-	e.SetExchangeAssetCurrencySettings(asset.Spot, currency.NewPair(currency.BTC, currency.USDT), cs)
-	result, err := e.GetCurrencySettings(testExchange, asset.Spot, currency.NewPair(currency.BTC, currency.USDT))
+	e.SetExchangeAssetCurrencySettings(asset.Spot, currency.NewBTCUSDT(), cs)
+	result, err := e.GetCurrencySettings(testExchange, asset.Spot, currency.NewBTCUSDT())
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
 	}
 	if !result.UseRealOrders {
 		t.Error("expected true")
 	}
-	e.SetExchangeAssetCurrencySettings(asset.Spot, currency.NewPair(currency.BTC, currency.USDT), cs)
+	e.SetExchangeAssetCurrencySettings(asset.Spot, currency.NewBTCUSDT(), cs)
 	if len(e.CurrencySettings) != 1 {
 		t.Error("expected 1")
 	}
@@ -213,7 +213,7 @@ func TestPlaceOrder(t *testing.T) {
 	_, err = e.placeOrder(t.Context(), decimal.NewFromInt(1), decimal.NewFromInt(1), decimal.Zero, false, true, f, bot.OrderManager)
 	assert.ErrorIs(t, err, gctorder.ErrPairIsEmpty)
 
-	f.CurrencyPair = currency.NewPair(currency.BTC, currency.USDT)
+	f.CurrencyPair = currency.NewBTCUSDT()
 	f.AssetType = asset.Spot
 	f.Direction = gctorder.Buy
 	_, err = e.placeOrder(t.Context(), decimal.NewFromInt(1), decimal.NewFromInt(1), decimal.Zero, false, true, f, bot.OrderManager)
@@ -240,7 +240,7 @@ func TestExecuteOrder(t *testing.T) {
 	err = bot.OrderManager.Start()
 	require.NoError(t, err, "OrderManager.Start must not error")
 
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	a := asset.Spot
 	require.NoError(t, exchB.CurrencyPairs.SetAssetEnabled(a, true), "SetAssetEnabled must not error")
 	_, err = exch.UpdateOrderbook(t.Context(), p, a)

backtester/eventhandlers/exchange/slippage/slippage_test.go

@@ -24,7 +24,7 @@ func TestCalculateSlippageByOrderbook(t *testing.T) {
 	b := bitstamp.Bitstamp{}
 	b.SetDefaults()
 
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	ob, err := b.UpdateOrderbook(t.Context(), cp, asset.Spot)
 	require.NoError(t, err, "UpdateOrderbook must not error")
 

backtester/eventhandlers/portfolio/holdings/holdings_test.go

@@ -151,7 +151,7 @@ func TestUpdateBuyStats(t *testing.T) {
 			Exchange:     testExchange,
 			Time:         time.Now(),
 			Interval:     gctkline.OneHour,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USDT),
+			CurrencyPair: currency.NewBTCUSDT(),
 			AssetType:    asset.Spot,
 		},
 		Direction:           order.Buy,
@@ -171,7 +171,7 @@ func TestUpdateBuyStats(t *testing.T) {
 			Date:        time.Now(),
 			CloseTime:   time.Now(),
 			LastUpdated: time.Now(),
-			Pair:        currency.NewPair(currency.BTC, currency.USDT),
+			Pair:        currency.NewBTCUSDT(),
 			Trades:      nil,
 			Fee:         1,
 		},
@@ -206,7 +206,7 @@ func TestUpdateBuyStats(t *testing.T) {
 			Exchange:     testExchange,
 			Time:         time.Now(),
 			Interval:     gctkline.OneHour,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USDT),
+			CurrencyPair: currency.NewBTCUSDT(),
 			AssetType:    asset.Spot,
 		},
 		Direction:           order.Buy,
@@ -226,7 +226,7 @@ func TestUpdateBuyStats(t *testing.T) {
 			Date:        time.Now(),
 			CloseTime:   time.Now(),
 			LastUpdated: time.Now(),
-			Pair:        currency.NewPair(currency.BTC, currency.USDT),
+			Pair:        currency.NewBTCUSDT(),
 			Trades:      nil,
 			Fee:         0.5,
 		},
@@ -272,7 +272,7 @@ func TestUpdateSellStats(t *testing.T) {
 			Exchange:     testExchange,
 			Time:         time.Now(),
 			Interval:     gctkline.OneHour,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USDT),
+			CurrencyPair: currency.NewBTCUSDT(),
 			AssetType:    asset.Spot,
 		},
 		Direction:           order.Buy,
@@ -292,7 +292,7 @@ func TestUpdateSellStats(t *testing.T) {
 			Date:        time.Now(),
 			CloseTime:   time.Now(),
 			LastUpdated: time.Now(),
-			Pair:        currency.NewPair(currency.BTC, currency.USDT),
+			Pair:        currency.NewBTCUSDT(),
 			Fee:         1,
 		},
 	}, p)
@@ -329,7 +329,7 @@ func TestUpdateSellStats(t *testing.T) {
 			Exchange:     testExchange,
 			Time:         time.Now(),
 			Interval:     gctkline.OneHour,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USDT),
+			CurrencyPair: currency.NewBTCUSDT(),
 			AssetType:    asset.Spot,
 		},
 		Direction:           order.Sell,
@@ -349,7 +349,7 @@ func TestUpdateSellStats(t *testing.T) {
 			Date:        time.Now(),
 			CloseTime:   time.Now(),
 			LastUpdated: time.Now(),
-			Pair:        currency.NewPair(currency.BTC, currency.USDT),
+			Pair:        currency.NewBTCUSDT(),
 			Trades:      nil,
 			Fee:         1,
 		},

backtester/eventhandlers/portfolio/portfolio_test.go

@@ -103,7 +103,7 @@ func TestSetupCurrencySettingsMap(t *testing.T) {
 		t.Errorf("received: %v, expected: %v", err, errCurrencyPairUnset)
 	}
 
-	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewPair(currency.BTC, currency.USDT)})
+	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSDT()})
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
 	}
@@ -126,14 +126,14 @@ func TestSetHoldings(t *testing.T) {
 
 	ff := &binance.Binance{}
 	ff.Name = testExchange
-	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewPair(currency.BTC, currency.USDT)})
+	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSDT()})
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
 	}
 	err = p.SetHoldingsForTimestamp(&holdings.Holding{
 		Exchange:  testExchange,
 		Asset:     asset.Spot,
-		Pair:      currency.NewPair(currency.BTC, currency.USDT),
+		Pair:      currency.NewBTCUSDT(),
 		Timestamp: tt,
 	})
 	if !errors.Is(err, nil) {
@@ -143,7 +143,7 @@ func TestSetHoldings(t *testing.T) {
 	err = p.SetHoldingsForTimestamp(&holdings.Holding{
 		Exchange:  testExchange,
 		Asset:     asset.Spot,
-		Pair:      currency.NewPair(currency.BTC, currency.USDT),
+		Pair:      currency.NewBTCUSDT(),
 		Timestamp: tt,
 	})
 	if !errors.Is(err, nil) {
@@ -162,7 +162,7 @@ func TestGetLatestHoldingsForAllCurrencies(t *testing.T) {
 	err := p.SetHoldingsForTimestamp(&holdings.Holding{
 		Exchange:  testExchange,
 		Asset:     asset.Spot,
-		Pair:      currency.NewPair(currency.BTC, currency.USDT),
+		Pair:      currency.NewBTCUSDT(),
 		Timestamp: tt,
 	})
 	if !errors.Is(err, errNoPortfolioSettings) {
@@ -171,7 +171,7 @@ func TestGetLatestHoldingsForAllCurrencies(t *testing.T) {
 
 	ff := &binance.Binance{}
 	ff.Name = testExchange
-	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewPair(currency.BTC, currency.USDT)})
+	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSDT()})
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
 	}
@@ -183,7 +183,7 @@ func TestGetLatestHoldingsForAllCurrencies(t *testing.T) {
 		Offset:    1,
 		Exchange:  testExchange,
 		Asset:     asset.Spot,
-		Pair:      currency.NewPair(currency.BTC, currency.USDT),
+		Pair:      currency.NewBTCUSDT(),
 		Timestamp: tt,
 	})
 	if !errors.Is(err, nil) {
@@ -197,7 +197,7 @@ func TestGetLatestHoldingsForAllCurrencies(t *testing.T) {
 		Offset:    1,
 		Exchange:  testExchange,
 		Asset:     asset.Spot,
-		Pair:      currency.NewPair(currency.BTC, currency.USDT),
+		Pair:      currency.NewBTCUSDT(),
 		Timestamp: tt,
 	})
 	if !errors.Is(err, nil) {
@@ -218,7 +218,7 @@ func TestViewHoldingAtTimePeriod(t *testing.T) {
 			Time:         tt,
 			Exchange:     testExchange,
 			AssetType:    asset.Spot,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USDT),
+			CurrencyPair: currency.NewBTCUSDT(),
 		},
 	}
 	_, err := p.ViewHoldingAtTimePeriod(s)
@@ -228,7 +228,7 @@ func TestViewHoldingAtTimePeriod(t *testing.T) {
 
 	ff := &binance.Binance{}
 	ff.Name = testExchange
-	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewPair(currency.BTC, currency.USDT)})
+	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSDT()})
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
 	}
@@ -242,7 +242,7 @@ func TestViewHoldingAtTimePeriod(t *testing.T) {
 		Offset:    1,
 		Exchange:  testExchange,
 		Asset:     asset.Spot,
-		Pair:      currency.NewPair(currency.BTC, currency.USDT),
+		Pair:      currency.NewBTCUSDT(),
 		Timestamp: tt,
 	})
 	if !errors.Is(err, nil) {
@@ -252,7 +252,7 @@ func TestViewHoldingAtTimePeriod(t *testing.T) {
 		Offset:    2,
 		Exchange:  testExchange,
 		Asset:     asset.Spot,
-		Pair:      currency.NewPair(currency.BTC, currency.USDT),
+		Pair:      currency.NewBTCUSDT(),
 		Timestamp: tt.Add(time.Hour),
 	})
 	if !errors.Is(err, nil) {
@@ -306,7 +306,7 @@ func TestUpdate(t *testing.T) {
 		Offset:    1,
 		Exchange:  testExchange,
 		Asset:     asset.Spot,
-		Pair:      currency.NewPair(currency.BTC, currency.USDT),
+		Pair:      currency.NewBTCUSDT(),
 		Timestamp: tt,
 	})
 	if !errors.Is(err, errNoPortfolioSettings) {
@@ -315,13 +315,13 @@ func TestUpdate(t *testing.T) {
 
 	ff := &binance.Binance{}
 	ff.Name = testExchange
-	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewPair(currency.BTC, currency.USDT)})
+	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSDT()})
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
 	}
 	b.Time = tt
 	b.Exchange = testExchange
-	b.CurrencyPair = currency.NewPair(currency.BTC, currency.USDT)
+	b.CurrencyPair = currency.NewBTCUSDT()
 	b.AssetType = asset.Spot
 	err = p.UpdateHoldings(&kline.Kline{
 		Base: b,
@@ -341,12 +341,12 @@ func TestGetComplianceManager(t *testing.T) {
 
 	ff := &binance.Binance{}
 	ff.Name = testExchange
-	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewPair(currency.BTC, currency.USDT)})
+	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSDT()})
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
 	}
 	var cm *compliance.Manager
-	cm, err = p.getComplianceManager(testExchange, asset.Spot, currency.NewPair(currency.BTC, currency.USDT))
+	cm, err = p.getComplianceManager(testExchange, asset.Spot, currency.NewBTCUSDT())
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
 	}
@@ -372,7 +372,7 @@ func TestAddComplianceSnapshot(t *testing.T) {
 
 	ff := &binance.Binance{}
 	ff.Name = testExchange
-	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewPair(currency.BTC, currency.USDT)})
+	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSDT()})
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
 	}
@@ -380,12 +380,12 @@ func TestAddComplianceSnapshot(t *testing.T) {
 	err = p.addComplianceSnapshot(&fill.Fill{
 		Base: &event.Base{
 			Exchange:     testExchange,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USDT),
+			CurrencyPair: currency.NewBTCUSDT(),
 			AssetType:    asset.Spot,
 		},
 		Order: &gctorder.Detail{
 			Exchange:  testExchange,
-			Pair:      currency.NewPair(currency.BTC, currency.USDT),
+			Pair:      currency.NewBTCUSDT(),
 			AssetType: asset.Spot,
 		},
 	})
@@ -405,12 +405,12 @@ func TestOnFill(t *testing.T) {
 	f := &fill.Fill{
 		Base: &event.Base{
 			Exchange:     testExchange,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USDT),
+			CurrencyPair: currency.NewBTCUSDT(),
 			AssetType:    asset.Spot,
 		},
 		Order: &gctorder.Detail{
 			Exchange:  testExchange,
-			Pair:      currency.NewPair(currency.BTC, currency.USDT),
+			Pair:      currency.NewBTCUSDT(),
 			AssetType: asset.Spot,
 		},
 	}
@@ -420,7 +420,7 @@ func TestOnFill(t *testing.T) {
 	}
 	ff := &binance.Binance{}
 	ff.Name = testExchange
-	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewPair(currency.BTC, currency.USDT)})
+	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSDT()})
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
 	}
@@ -507,12 +507,12 @@ func TestOnSignal(t *testing.T) {
 	}
 	ff := &binance.Binance{}
 	ff.Name = testExchange
-	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewPair(currency.BTC, currency.USD)})
+	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSD()})
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
 	}
 	b.Exchange = testExchange
-	b.CurrencyPair = currency.NewPair(currency.BTC, currency.USD)
+	b.CurrencyPair = currency.NewBTCUSD()
 	b.AssetType = asset.Spot
 	s = &signal.Signal{
 		Base:      b,
@@ -546,14 +546,14 @@ func TestOnSignal(t *testing.T) {
 	err = p.SetHoldingsForTimestamp(&holdings.Holding{
 		Exchange:  "lol",
 		Asset:     asset.Spot,
-		Pair:      currency.NewPair(currency.BTC, currency.USD),
+		Pair:      currency.NewBTCUSD(),
 		Timestamp: time.Now(),
 		QuoteSize: leet,
 	})
 	if !errors.Is(err, errNoPortfolioSettings) {
 		t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
 	}
-	cs := &exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewPair(currency.BTC, currency.USD)}
+	cs := &exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSD()}
 	err = p.SetCurrencySettingsMap(cs)
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
@@ -601,7 +601,7 @@ func TestOnSignal(t *testing.T) {
 	if !errors.Is(err, errNoPortfolioSettings) {
 		t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
 	}
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	_, err = p.getSettings(testExchange, asset.Futures, cp)
 	if !errors.Is(err, errNoPortfolioSettings) {
 		t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
@@ -629,7 +629,7 @@ func TestOnSignal(t *testing.T) {
 		Status:        gctorder.AnyStatus,
 		AssetType:     asset.Futures,
 		Date:          time.Now(),
-		Pair:          currency.NewPair(currency.BTC, currency.USD),
+		Pair:          currency.NewBTCUSD(),
 	})
 	if !errors.Is(err, nil) {
 		t.Errorf("received: %v, expected: %v", err, nil)
@@ -952,7 +952,7 @@ func TestTrackFuturesOrder(t *testing.T) {
 	if !errors.Is(err, funding.ErrNotCollateral) {
 		t.Errorf("received '%v' expected '%v", err, funding.ErrNotCollateral)
 	}
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	od.Pair = cp
 	od.Exchange = testExchange
 	od.Side = gctorder.Short
@@ -1083,7 +1083,7 @@ func TestGetPositions(t *testing.T) {
 	ev := &fill.Fill{
 		Base: &event.Base{
 			Exchange:     testExchange,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USD),
+			CurrencyPair: currency.NewBTCUSD(),
 			AssetType:    asset.Futures,
 		},
 	}
@@ -1111,7 +1111,7 @@ func TestGetLatestPNLForEvent(t *testing.T) {
 	ev := &fill.Fill{
 		Base: &event.Base{
 			Exchange:     testExchange,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USD),
+			CurrencyPair: currency.NewBTCUSD(),
 			AssetType:    asset.Futures,
 		},
 	}
@@ -1187,7 +1187,7 @@ func TestGetFuturesSettingsFromEvent(t *testing.T) {
 		t.Fatalf("received '%v' expected '%v'", err, futures.ErrNotFuturesAsset)
 	}
 	b.Exchange = testExchange
-	b.CurrencyPair = currency.NewPair(currency.BTC, currency.USDT)
+	b.CurrencyPair = currency.NewBTCUSDT()
 	b.AssetType = asset.Futures
 	ev := &fill.Fill{
 		Base: b,
@@ -1219,7 +1219,7 @@ func TestGetUnrealisedPNL(t *testing.T) {
 	p := PNLSummary{
 		Exchange:           testExchange,
 		Asset:              asset.Futures,
-		Pair:               currency.NewPair(currency.BTC, currency.USDT),
+		Pair:               currency.NewBTCUSDT(),
 		CollateralCurrency: currency.USDT,
 		Offset:             1,
 		Result: futures.PNLResult{
@@ -1251,7 +1251,7 @@ func TestGetRealisedPNL(t *testing.T) {
 	p := PNLSummary{
 		Exchange:           testExchange,
 		Asset:              asset.Futures,
-		Pair:               currency.NewPair(currency.BTC, currency.USDT),
+		Pair:               currency.NewBTCUSDT(),
 		CollateralCurrency: currency.USDT,
 		Offset:             1,
 		Result: futures.PNLResult{
@@ -1283,7 +1283,7 @@ func TestGetExposure(t *testing.T) {
 	p := PNLSummary{
 		Exchange:           testExchange,
 		Asset:              asset.Futures,
-		Pair:               currency.NewPair(currency.BTC, currency.USDT),
+		Pair:               currency.NewBTCUSDT(),
 		CollateralCurrency: currency.USDT,
 		Offset:             1,
 		Result: futures.PNLResult{
@@ -1308,7 +1308,7 @@ func TestGetCollateralCurrency(t *testing.T) {
 	p := PNLSummary{
 		Exchange:           testExchange,
 		Asset:              asset.Futures,
-		Pair:               currency.NewPair(currency.BTC, currency.USDT),
+		Pair:               currency.NewBTCUSDT(),
 		CollateralCurrency: currency.USDT,
 		Offset:             1,
 		Result: futures.PNLResult{
@@ -1334,7 +1334,7 @@ func TestGetDirection(t *testing.T) {
 	p := PNLSummary{
 		Exchange:           testExchange,
 		Asset:              asset.Futures,
-		Pair:               currency.NewPair(currency.BTC, currency.USDT),
+		Pair:               currency.NewBTCUSDT(),
 		CollateralCurrency: currency.USDT,
 		Offset:             1,
 		Result: futures.PNLResult{
@@ -1452,7 +1452,7 @@ func TestCreateLiquidationOrdersForExchange(t *testing.T) {
 
 	ff := &binance.Binance{}
 	ff.Name = testExchange
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Futures, Pair: cp})
 	if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
 		t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNotYetImplemented)
@@ -1570,7 +1570,7 @@ func TestCheckLiquidationStatus(t *testing.T) {
 	}
 
 	item := asset.Futures
-	pair := currency.NewPair(currency.BTC, currency.USDT)
+	pair := currency.NewBTCUSDT()
 	contract, err := funding.CreateItem(testExchange, item, pair.Base, decimal.NewFromInt(100), decimal.Zero)
 	if !errors.Is(err, nil) {
 		t.Errorf("received '%v' expected '%v", err, nil)

backtester/eventhandlers/portfolio/risk/risk_test.go

@@ -18,9 +18,9 @@ import (
 
 func TestAssessHoldingsRatio(t *testing.T) {
 	t.Parallel()
-	ratio := assessHoldingsRatio(currency.NewPair(currency.BTC, currency.USDT), []holdings.Holding{
+	ratio := assessHoldingsRatio(currency.NewBTCUSDT(), []holdings.Holding{
 		{
-			Pair:      currency.NewPair(currency.BTC, currency.USDT),
+			Pair:      currency.NewBTCUSDT(),
 			BaseValue: decimal.NewFromInt(2),
 		},
 		{
@@ -32,9 +32,9 @@ func TestAssessHoldingsRatio(t *testing.T) {
 		t.Errorf("expected %v received %v", 0.5, ratio)
 	}
 
-	ratio = assessHoldingsRatio(currency.NewPair(currency.BTC, currency.USDT), []holdings.Holding{
+	ratio = assessHoldingsRatio(currency.NewBTCUSDT(), []holdings.Holding{
 		{
-			Pair:      currency.NewPair(currency.BTC, currency.USDT),
+			Pair:      currency.NewBTCUSDT(),
 			BaseValue: decimal.NewFromInt(1),
 		},
 		{
@@ -58,7 +58,7 @@ func TestEvaluateOrder(t *testing.T) {
 	if !errors.Is(err, gctcommon.ErrNilPointer) {
 		t.Error(err)
 	}
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	e := "binance"
 	a := asset.Spot
 	o := &order.Order{

backtester/eventhandlers/portfolio/size/size_test.go

@@ -196,8 +196,8 @@ func TestSizeOrder(t *testing.T) {
 			Offset:         1,
 			Exchange:       "binance",
 			Time:           time.Now(),
-			CurrencyPair:   currency.NewPair(currency.BTC, currency.USDT),
-			UnderlyingPair: currency.NewPair(currency.BTC, currency.USDT),
+			CurrencyPair:   currency.NewBTCUSDT(),
+			UnderlyingPair: currency.NewBTCUSDT(),
 			AssetType:      asset.Spot,
 		},
 	}

backtester/eventhandlers/statistics/currencystatistics_test.go

@@ -28,7 +28,7 @@ func TestCalculateResults(t *testing.T) {
 	tt1 := time.Now()
 	tt2 := time.Now().Add(gctkline.OneDay.Duration())
 	exch := testExchange
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	even := &event.Base{
 		Exchange:     exch,
 		Time:         tt1,
@@ -163,7 +163,7 @@ func TestPrintResults(t *testing.T) {
 	tt2 := time.Now().Add(gctkline.OneDay.Duration())
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	even := &event.Base{
 		Exchange:     exch,
 		Time:         tt1,
@@ -310,7 +310,7 @@ func TestAnalysePNLGrowth(t *testing.T) {
 
 	e := testExchange
 	a := asset.Futures
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	c.Asset = asset.Futures
 	c.Events = append(c.Events,
 		DataAtOffset{PNL: &portfolio.PNLSummary{

backtester/eventhandlers/statistics/fundingstatistics_test.go

@@ -53,7 +53,7 @@ func TestCalculateFundingStatistics(t *testing.T) {
 
 	usdKline := gctkline.Item{
 		Exchange: "binance",
-		Pair:     currency.NewPair(currency.BTC, currency.USD),
+		Pair:     currency.NewBTCUSD(),
 		Asset:    asset.Spot,
 		Interval: gctkline.OneHour,
 		Candles: []gctkline.Candle{
@@ -176,7 +176,7 @@ func TestCalculateIndividualFundingStatistics(t *testing.T) {
 	if !errors.Is(err, errMissingSnapshots) {
 		t.Errorf("received %v expected %v", err, errMissingSnapshots)
 	}
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	ri.USDPairCandle = &kline.DataFromKline{
 		Base: &data.Base{},
 		Item: &gctkline.Item{

backtester/eventhandlers/statistics/statistics_test.go

@@ -60,7 +60,7 @@ func TestAddDataEventForTime(t *testing.T) {
 	tt := time.Now()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	s := Statistic{}
 	err := s.SetEventForOffset(nil)
 	if !errors.Is(err, common.ErrNilEvent) {
@@ -101,7 +101,7 @@ func TestAddSignalEventForTime(t *testing.T) {
 	tt := time.Now()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	s := Statistic{}
 	err := s.SetEventForOffset(nil)
 	if !errors.Is(err, common.ErrNilEvent) {
@@ -150,7 +150,7 @@ func TestAddExchangeEventForTime(t *testing.T) {
 	tt := time.Now()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	s := Statistic{}
 	err := s.SetEventForOffset(nil)
 	if !errors.Is(err, common.ErrNilEvent) {
@@ -199,7 +199,7 @@ func TestAddFillEventForTime(t *testing.T) {
 	tt := time.Now()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	s := Statistic{}
 	err := s.SetEventForOffset(nil)
 	if !errors.Is(err, common.ErrNilEvent) {
@@ -255,7 +255,7 @@ func TestAddHoldingsForTime(t *testing.T) {
 	tt := time.Now()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	s := Statistic{}
 	err := s.AddHoldingsForTime(&holdings.Holding{})
 	if !errors.Is(err, errExchangeAssetPairStatsUnset) {
@@ -314,7 +314,7 @@ func TestAddComplianceSnapshotForTime(t *testing.T) {
 	tt := time.Now()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	s := Statistic{}
 
 	err := s.AddComplianceSnapshotForTime(nil, nil)
@@ -500,7 +500,7 @@ func TestPrintAllEventsChronologically(t *testing.T) {
 	tt := time.Now()
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	err := s.SetEventForOffset(nil)
 	if !errors.Is(err, common.ErrNilEvent) {
 		t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
@@ -573,7 +573,7 @@ func TestCalculateTheResults(t *testing.T) {
 	tt2 := time.Now().Add(-gctkline.OneDay.Duration() * 6)
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	p2 := currency.NewPair(currency.XRP, currency.DOGE)
 	err = s.SetEventForOffset(nil)
 	if !errors.Is(err, common.ErrNilEvent) {
@@ -824,7 +824,7 @@ func TestCalculateBiggestEventDrawdown(t *testing.T) {
 	tt1 := time.Now().Add(-gctkline.OneDay.Duration() * 7).Round(gctkline.OneDay.Duration())
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	var events []data.Event
 	for i := range int64(100) {
 		tt1 = tt1.Add(gctkline.OneDay.Duration())
@@ -960,7 +960,7 @@ func TestAddPNLForTime(t *testing.T) {
 	tt := time.Now().Add(-gctkline.OneDay.Duration() * 7)
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	err = s.SetEventForOffset(&kline.Kline{
 		Base: &event.Base{
 			Exchange:     exch,

backtester/eventhandlers/strategies/base/base_test.go

@@ -32,7 +32,7 @@ func TestGetBase(t *testing.T) {
 	tt := time.Now()
 	exch := "binance"
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := &data.Base{}
 	err = d.SetStream([]data.Event{&kline.Kline{
 		Base: &event.Base{

backtester/eventhandlers/strategies/binancecashandcarry/binancecashandcarry_test.go

@@ -116,7 +116,7 @@ func TestSortSignals(t *testing.T) {
 	dInsert := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 	exch := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := &data.Base{}
 	err := d.SetStream([]data.Event{&eventkline.Kline{
 		Base: &event.Base{
@@ -321,7 +321,7 @@ func (p portfolerino) GetPositions(common.Event) ([]futures.Position, error) {
 		{
 			Exchange:           exchangeName,
 			Asset:              asset.Spot,
-			Pair:               currency.NewPair(currency.BTC, currency.USD),
+			Pair:               currency.NewBTCUSD(),
 			Underlying:         currency.BTC,
 			CollateralCurrency: currency.USD,
 		},
@@ -336,14 +336,14 @@ func TestOnSimultaneousSignals(t *testing.T) {
 		t.Errorf("received '%v' expected '%v", err, base.ErrNoDataToProcess)
 	}
 
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	d := &datakline.DataFromKline{
 		Base: &data.Base{},
 		Item: &gctkline.Item{
 			Exchange:       exchangeName,
 			Asset:          asset.Spot,
 			Pair:           cp,
-			UnderlyingPair: currency.NewPair(currency.BTC, currency.USD),
+			UnderlyingPair: currency.NewBTCUSD(),
 		},
 	}
 	tt := time.Now()
@@ -450,7 +450,7 @@ func TestCloseAllPositions(t *testing.T) {
 		t.Errorf("received '%v' expected '%v", err, nil)
 	}
 	leet := decimal.NewFromInt(1337)
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	h := []holdings.Holding{
 		{
 			Offset:   1,

backtester/eventhandlers/strategies/dollarcostaverage/dollarcostaverage_test.go

@@ -52,7 +52,7 @@ func TestOnSignal(t *testing.T) {
 	dEnd := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 	exch := "binance"
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := &data.Base{}
 	err = d.SetStream([]data.Event{&eventkline.Kline{
 		Base: &event.Base{
@@ -139,7 +139,7 @@ func TestOnSignals(t *testing.T) {
 	dEnd := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 	exch := "binance"
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := &data.Base{}
 	err = d.SetStream([]data.Event{&eventkline.Kline{
 		Base: &event.Base{

backtester/eventhandlers/strategies/rsi/rsi_test.go

@@ -93,7 +93,7 @@ func TestOnSignal(t *testing.T) {
 	dEnd := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 	exch := "binance"
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := &data.Base{}
 	err = d.SetStream([]data.Event{&eventkline.Kline{
 		Base: &event.Base{
@@ -184,7 +184,7 @@ func TestOnSignals(t *testing.T) {
 	dInsert := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 	exch := "binance"
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := &data.Base{}
 	err = d.SetStream([]data.Event{&eventkline.Kline{
 		Base: &event.Base{

backtester/eventhandlers/strategies/top2bottom2/top2bottom2_test.go

@@ -107,7 +107,7 @@ func TestOnSignals(t *testing.T) {
 	dInsert := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 	exch := "binance"
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := &data.Base{}
 	err = d.SetStream([]data.Event{&eventkline.Kline{
 		Base: &event.Base{

backtester/eventtypes/event/event_test.go

@@ -93,7 +93,7 @@ func TestIsEvent(t *testing.T) {
 func TestPair(t *testing.T) {
 	t.Parallel()
 	e := &Base{
-		CurrencyPair: currency.NewPair(currency.BTC, currency.USDT),
+		CurrencyPair: currency.NewBTCUSDT(),
 	}
 	y := e.Pair()
 	if y.IsEmpty() {
@@ -148,7 +148,7 @@ func TestGetBase(t *testing.T) {
 func TestGetUnderlyingPair(t *testing.T) {
 	t.Parallel()
 	b1 := &Base{
-		UnderlyingPair: currency.NewPair(currency.BTC, currency.USDT),
+		UnderlyingPair: currency.NewBTCUSDT(),
 	}
 	if !b1.UnderlyingPair.Equal(b1.GetUnderlyingPair()) {
 		t.Errorf("expected '%v' received '%v'", b1.UnderlyingPair, b1.GetUnderlyingPair())

backtester/eventtypes/order/order_test.go

@@ -44,7 +44,7 @@ func TestIsEmpty(t *testing.T) {
 	t.Parallel()
 	o := Order{
 		Base: &event.Base{
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USDT),
+			CurrencyPair: currency.NewBTCUSDT(),
 		},
 	}
 	y := o.CurrencyPair
@@ -130,7 +130,7 @@ func TestGetSellLimit(t *testing.T) {
 
 func TestPair(t *testing.T) {
 	t.Parallel()
-	cp := currency.NewPair(currency.BTC, currency.USDT)
+	cp := currency.NewBTCUSDT()
 	k := Order{
 		Base: &event.Base{
 			CurrencyPair: cp,

backtester/funding/funding_test.go

@@ -395,7 +395,7 @@ func TestGenerateReport(t *testing.T) {
 		Base: &data.Base{},
 		Item: &gctkline.Item{
 			Exchange: exchName,
-			Pair:     currency.NewPair(currency.BTC, currency.USDT),
+			Pair:     currency.NewBTCUSDT(),
 			Asset:    a,
 			Interval: gctkline.OneHour,
 			Candles: []gctkline.Candle{
@@ -589,7 +589,7 @@ func TestFundingLiquidate(t *testing.T) {
 		Base: &event.Base{
 			Exchange:     "test",
 			AssetType:    asset.Spot,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USDT),
+			CurrencyPair: currency.NewBTCUSDT(),
 		},
 	})
 	if !errors.Is(err, nil) {
@@ -617,7 +617,7 @@ func TestHasExchangeBeenLiquidated(t *testing.T) {
 		Base: &event.Base{
 			Exchange:     "test",
 			AssetType:    asset.Spot,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USDT),
+			CurrencyPair: currency.NewBTCUSDT(),
 		},
 	}
 	err = f.Liquidate(ev)
@@ -751,7 +751,7 @@ func TestUpdateCollateral(t *testing.T) {
 		Base: &event.Base{
 			Exchange:     exchName,
 			AssetType:    asset.Futures,
-			CurrencyPair: currency.NewPair(currency.BTC, currency.USD),
+			CurrencyPair: currency.NewBTCUSD(),
 		},
 	}
 	f.items = append(f.items, &Item{

backtester/funding/trackingcurrencies/trackingcurrencies_test.go

@@ -92,8 +92,8 @@ func TestFindMatchingUSDPairs(t *testing.T) {
 	tests := []testPair{
 		{
 			description:    "already has USDT",
-			initialPair:    currency.NewPair(currency.BTC, currency.USDT),
-			availablePairs: &currency.PairStore{Available: currency.Pairs{currency.NewPair(currency.BTC, currency.USDT)}},
+			initialPair:    currency.NewBTCUSDT(),
+			availablePairs: &currency.PairStore{Available: currency.Pairs{currency.NewBTCUSDT()}},
 			basePair:       currency.EMPTYPAIR,
 			quotePair:      currency.EMPTYPAIR,
 			expectedErr:    ErrCurrencyContainsUSD,
@@ -101,8 +101,8 @@ func TestFindMatchingUSDPairs(t *testing.T) {
 		{
 			description:    "successful",
 			initialPair:    currency.NewPair(currency.BTC, currency.LTC),
-			availablePairs: &currency.PairStore{Available: currency.Pairs{currency.NewPair(currency.BTC, currency.LTC), currency.NewPair(currency.BTC, currency.USDT), currency.NewPair(currency.LTC, currency.TUSD)}},
-			basePair:       currency.NewPair(currency.BTC, currency.USDT),
+			availablePairs: &currency.PairStore{Available: currency.Pairs{currency.NewPair(currency.BTC, currency.LTC), currency.NewBTCUSDT(), currency.NewPair(currency.LTC, currency.TUSD)}},
+			basePair:       currency.NewBTCUSDT(),
 			quotePair:      currency.NewPair(currency.LTC, currency.TUSD),
 			expectedErr:    nil,
 		},
@@ -167,7 +167,7 @@ func TestPairContainsUSD(t *testing.T) {
 		{
 			"btcusdt",
 			true,
-			currency.NewPair(currency.BTC, currency.USDT),
+			currency.NewBTCUSDT(),
 		},
 		{
 			"btcdoge",
@@ -192,7 +192,7 @@ func TestPairContainsUSD(t *testing.T) {
 		{
 			"btcusd",
 			true,
-			currency.NewPair(currency.BTC, currency.USDT),
+			currency.NewBTCUSDT(),
 		},
 		{
 			"btcaud",

backtester/report/chart_test.go

@@ -135,7 +135,7 @@ func TestCreatePNLCharts(t *testing.T) {
 
 	err = d.SetKlineData(&gctkline.Item{
 		Exchange: testExchange,
-		Pair:     currency.NewPair(currency.BTC, currency.USDT),
+		Pair:     currency.NewBTCUSDT(),
 		Asset:    asset.Spot,
 		Interval: gctkline.OneDay,
 		Candles: []gctkline.Candle{
@@ -171,7 +171,7 @@ func TestCreateFuturesSpotDiffChart(t *testing.T) {
 	}
 
 	tt := time.Now()
-	cp := currency.NewPair(currency.BTC, currency.USD)
+	cp := currency.NewBTCUSD()
 	cp2 := currency.NewPair(currency.BTC, currency.DOGE)
 	var d Data
 	d.Statistics = &statistics.Statistic{}

backtester/report/report_test.go

@@ -23,7 +23,7 @@ func TestGenerateReport(t *testing.T) {
 	t.Parallel()
 	e := testExchange
 	a := asset.Spot
-	p := currency.NewPair(currency.BTC, currency.USDT)
+	p := currency.NewBTCUSDT()
 	d := Data{
 		Config: &config.Config{
 			StrategySettings: config.StrategySettings{
@@ -137,7 +137,7 @@ func TestGenerateReport(t *testing.T) {
 			{
 				Exchange:  "Bitstamp",
 				Asset:     a,
-				Pair:      currency.NewPair(currency.BTC, currency.USD),
+				Pair:      currency.NewBTCUSD(),
 				Interval:  gctkline.OneDay,
 				Watermark: "BITSTAMP - SPOT - BTC-USD - 1d",
 				Candles: []DetailedCandle{
@@ -349,7 +349,7 @@ func TestEnhanceCandles(t *testing.T) {
 
 	err = d.SetKlineData(&gctkline.Item{
 		Exchange: testExchange,
-		Pair:     currency.NewPair(currency.BTC, currency.USDT),
+		Pair:     currency.NewBTCUSDT(),
 		Asset:    asset.Spot,
 		Interval: gctkline.OneDay,
 		Candles: []gctkline.Candle{
@@ -373,7 +373,7 @@ func TestEnhanceCandles(t *testing.T) {
 
 	err = d.SetKlineData(&gctkline.Item{
 		Exchange: testExchange,
-		Pair:     currency.NewPair(currency.BTC, currency.USDT),
+		Pair:     currency.NewBTCUSDT(),
 		Asset:    asset.Spot,
 		Interval: gctkline.OneDay,
 		Candles: []gctkline.Candle{