qa/spelling: Add Codespell support (#1121)

* Add codespell support

* Fix paths

* Add HTML files to exclusion list

backtester/config/README.md

@@ -115,7 +115,7 @@ See below for a set of tables and fields, expected values and what they can do
 |------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------|
 | name                               | The strategy to use                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `rsi`                                                                     |
 | use-simultaneous-signal-processing | This denotes whether multiple currencies are processed simultaneously with the strategy function `OnSimultaneousSignals`. Eg If you have multiple CurrencySettings and only wish to purchase BTC-USDT when XRP-DOGE is 1337, this setting is useful as you can analyse both signal events to output a purchase call for BTC                                                                                                                                                                                                                                                                                                    | `true`                                                                    |
-| disable-usd-tracking               | If `false`, will track all currencies used in your strategy against USD equivalent candles. For example, if you are running a strategy for BTC/XRP, then the GoCryptoTrader Backtester will also retreive candles data for BTC/USD and XRP/USD to then track strategy performance against a single currency. This also tracks against USDT and other USD tracked stablecoins, so one exchange supporting USDT and another BUSD will still allow unified strategy performance analysis. If disabled, will not track against USD, this can be especially helpful when running strategies under live, database and CSV based data | `false`                                                                   |
+| disable-usd-tracking               | If `false`, will track all currencies used in your strategy against USD equivalent candles. For example, if you are running a strategy for BTC/XRP, then the GoCryptoTrader Backtester will also retrieve candles data for BTC/USD and XRP/USD to then track strategy performance against a single currency. This also tracks against USDT and other USD tracked stablecoins, so one exchange supporting USDT and another BUSD will still allow unified strategy performance analysis. If disabled, will not track against USD, this can be especially helpful when running strategies under live, database and CSV based data | `false`                                                                   |
 | custom-settings                    | This is a map where you can enter custom settings for a strategy. The RSI strategy allows for customisation of the upper, lower and length variables to allow you to change them from 70, 30 and 14 respectively to 69, 36, 12                                                                                                                                                                                                                                                                                                                                                                                                 | `"custom-settings": { "rsi-high": 70, "rsi-low": 30, "rsi-period": 14 } ` |
 
 #### Funding Config Settings
@@ -232,7 +232,7 @@ See below for a set of tables and fields, expected values and what they can do
 | data-check-timer             | The interval in which to check exchange API's for new data                                                                                      | `1000000000`  |
 | real-orders                  | Whether to place real orders with real money. Its likely you should never want to set this to true                                              | `false`       |
 | close-positions-on-stop      | As live trading doesn't stop until you tell it to, you can trigger a close of your position(s) when you stop the strategy                       | `true`        |
-| data-request-retry-tolerance | Rather than immediately closing a strategy on failure to retreive candle data, having a retry tolerance allows multiple attempts to return data | `3`           |
+| data-request-retry-tolerance | Rather than immediately closing a strategy on failure to retrieve candle data, having a retry tolerance allows multiple attempts to return data | `3`           |
 | data-request-retry-wait-time | How long to wait in between request retries                                                                                                     | `500000000`   |
 | exchange-credentials         | A list of exchange credentials. See table named `ExchangeCredentials`                                                                           |               |
 

backtester/eventhandlers/portfolio/portfolio.go

@@ -265,7 +265,7 @@ func (p *Portfolio) OnFill(ev fill.Event, funds funding.IFundReleaser) (fill.Eve
 	return ev, nil
 }
 
-// addComplianceSnapshot gets the previous snapshot of compliance events, updates with the latest fillevent
+// addComplianceSnapshot gets the previous snapshot of compliance events, updates with the latest fill event
 // then saves the snapshot to the c
 func (p *Portfolio) addComplianceSnapshot(fillEvent fill.Event) error {
 	if fillEvent == nil {
@@ -276,17 +276,17 @@ func (p *Portfolio) addComplianceSnapshot(fillEvent fill.Event) error {
 		return err
 	}
 	prevSnap := complianceManager.GetLatestSnapshot()
-	if fo := fillEvent.GetOrder(); fo != nil {
-		price := decimal.NewFromFloat(fo.Price)
-		amount := decimal.NewFromFloat(fo.Amount)
-		fee := decimal.NewFromFloat(fo.Fee)
+	if filledOrder := fillEvent.GetOrder(); filledOrder != nil {
+		price := decimal.NewFromFloat(filledOrder.Price)
+		amount := decimal.NewFromFloat(filledOrder.Amount)
+		fee := decimal.NewFromFloat(filledOrder.Fee)
 		snapOrder := compliance.SnapshotOrder{
 			ClosePrice:          fillEvent.GetClosePrice(),
 			VolumeAdjustedPrice: fillEvent.GetVolumeAdjustedPrice(),
 			SlippageRate:        fillEvent.GetSlippageRate(),
 			CostBasis:           price.Mul(amount).Add(fee),
 		}
-		snapOrder.Order = fo
+		snapOrder.Order = filledOrder
 		prevSnap.Orders = append(prevSnap.Orders, snapOrder)
 	}
 	snap := &compliance.Snapshot{

backtester/eventtypes/signal/signal_types.go

@@ -57,7 +57,7 @@ type Signal struct {
 	// if there is corresponding collateral in the selected currency
 	// this enabled cash and carry strategies for example
 	FillDependentEvent Event
-	// CollateralCurrency is an optional paramater
+	// CollateralCurrency is an optional parameter
 	// when using futures to limit the collateral available
 	// to a singular currency
 	// eg with $5000 usd and 1 BTC, specifying BTC ensures

backtester/funding/README.md

@@ -69,7 +69,7 @@ No. The already existing `CurrencySettings` will populate the funding manager wi
 |------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------|
 | name                               | The strategy to use                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `rsi`                                                                     |
 | use-simultaneous-signal-processing | This denotes whether multiple currencies are processed simultaneously with the strategy function `OnSimultaneousSignals`. Eg If you have multiple CurrencySettings and only wish to purchase BTC-USDT when XRP-DOGE is 1337, this setting is useful as you can analyse both signal events to output a purchase call for BTC                                                                                                                                                                                                                                                                                                    | `true`                                                                    |
-| disable-usd-tracking               | If `false`, will track all currencies used in your strategy against USD equivalent candles. For example, if you are running a strategy for BTC/XRP, then the GoCryptoTrader Backtester will also retreive candles data for BTC/USD and XRP/USD to then track strategy performance against a single currency. This also tracks against USDT and other USD tracked stablecoins, so one exchange supporting USDT and another BUSD will still allow unified strategy performance analysis. If disabled, will not track against USD, this can be especially helpful when running strategies under live, database and CSV based data | `false`                                                                   |
+| disable-usd-tracking               | If `false`, will track all currencies used in your strategy against USD equivalent candles. For example, if you are running a strategy for BTC/XRP, then the GoCryptoTrader Backtester will also retrieve candles data for BTC/USD and XRP/USD to then track strategy performance against a single currency. This also tracks against USDT and other USD tracked stablecoins, so one exchange supporting USDT and another BUSD will still allow unified strategy performance analysis. If disabled, will not track against USD, this can be especially helpful when running strategies under live, database and CSV based data | `false`                                                                   |
 | custom-settings                    | This is a map where you can enter custom settings for a strategy. The RSI strategy allows for customisation of the upper, lower and length variables to allow you to change them from 70, 30 and 14 respectively to 69, 36, 12                                                                                                                                                                                                                                                                                                                                                                                                 | `"custom-settings": { "rsi-high": 70, "rsi-low": 30, "rsi-period": 14 } ` |
 
 #### Funding Config Settings

backtester/funding/collateralpair_test.go

@@ -34,7 +34,7 @@ func TestCollateralTakeProfit(t *testing.T) {
 	var expectedError error
 	err := c.TakeProfit(decimal.NewFromInt(1), decimal.NewFromInt(1))
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 }
 
@@ -44,7 +44,7 @@ func TestCollateralCollateralCurrency(t *testing.T) {
 		collateral: &Item{currency: currency.DOGE},
 	}
 	if !c.CollateralCurrency().Equal(currency.DOGE) {
-		t.Errorf("recevied '%v' expected '%v'", c.CollateralCurrency(), currency.DOGE)
+		t.Errorf("received '%v' expected '%v'", c.CollateralCurrency(), currency.DOGE)
 	}
 }
 
@@ -54,7 +54,7 @@ func TestCollateralContractCurrency(t *testing.T) {
 		contract: &Item{currency: currency.DOGE},
 	}
 	if !c.ContractCurrency().Equal(currency.DOGE) {
-		t.Errorf("recevied '%v' expected '%v'", c.ContractCurrency(), currency.DOGE)
+		t.Errorf("received '%v' expected '%v'", c.ContractCurrency(), currency.DOGE)
 	}
 }
 
@@ -64,7 +64,7 @@ func TestCollateralInitialFunds(t *testing.T) {
 		collateral: &Item{initialFunds: decimal.NewFromInt(1337)},
 	}
 	if !c.InitialFunds().Equal(decimal.NewFromInt(1337)) {
-		t.Errorf("recevied '%v' expected '%v'", c.InitialFunds(), decimal.NewFromInt(1337))
+		t.Errorf("received '%v' expected '%v'", c.InitialFunds(), decimal.NewFromInt(1337))
 	}
 }
 
@@ -74,7 +74,7 @@ func TestCollateralAvailableFunds(t *testing.T) {
 		collateral: &Item{available: decimal.NewFromInt(1337)},
 	}
 	if !c.AvailableFunds().Equal(decimal.NewFromInt(1337)) {
-		t.Errorf("recevied '%v' expected '%v'", c.AvailableFunds(), decimal.NewFromInt(1337))
+		t.Errorf("received '%v' expected '%v'", c.AvailableFunds(), decimal.NewFromInt(1337))
 	}
 }
 
@@ -85,7 +85,7 @@ func TestCollateralGetPairReader(t *testing.T) {
 		collateral: &Item{},
 	}
 	if _, err := c.GetPairReader(); !errors.Is(err, ErrNotPair) {
-		t.Errorf("recevied '%v' expected '%v'", err, ErrNotPair)
+		t.Errorf("received '%v' expected '%v'", err, ErrNotPair)
 	}
 }
 
@@ -97,7 +97,7 @@ func TestCollateralGetCollateralReader(t *testing.T) {
 	var expectedError error
 	cr, err := c.GetCollateralReader()
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 	if cr != c {
 		t.Error("expected the same thing")
@@ -119,27 +119,27 @@ func TestCollateralUpdateContracts(t *testing.T) {
 	leet := decimal.NewFromInt(1337)
 	err := c.UpdateContracts(gctorder.Buy, leet)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 	if !c.contract.available.Equal(leet) {
-		t.Errorf("recevied '%v' expected '%v'", c.contract.available, leet)
+		t.Errorf("received '%v' expected '%v'", c.contract.available, leet)
 	}
 	b = gctorder.Sell
 	err = c.UpdateContracts(gctorder.Buy, leet)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 	if !c.contract.available.Equal(decimal.Zero) {
-		t.Errorf("recevied '%v' expected '%v'", c.contract.available, decimal.Zero)
+		t.Errorf("received '%v' expected '%v'", c.contract.available, decimal.Zero)
 	}
 
 	c.currentDirection = nil
 	err = c.UpdateContracts(gctorder.Buy, leet)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 	if !c.contract.available.Equal(leet) {
-		t.Errorf("recevied '%v' expected '%v'", c.contract.available, leet)
+		t.Errorf("received '%v' expected '%v'", c.contract.available, leet)
 	}
 }
 
@@ -158,20 +158,20 @@ func TestCollateralReleaseContracts(t *testing.T) {
 	expectedError := errPositiveOnly
 	err := c.ReleaseContracts(decimal.Zero)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 
 	expectedError = errCannotAllocate
 	err = c.ReleaseContracts(decimal.NewFromInt(1337))
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 
 	expectedError = nil
 	c.contract.available = decimal.NewFromInt(1337)
 	err = c.ReleaseContracts(decimal.NewFromInt(1337))
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 }
 
@@ -192,7 +192,7 @@ func TestCollateralPairReleaser(t *testing.T) {
 		contract:   &Item{},
 	}
 	if _, err := c.PairReleaser(); !errors.Is(err, ErrNotPair) {
-		t.Errorf("recevied '%v' expected '%v'", err, ErrNotPair)
+		t.Errorf("received '%v' expected '%v'", err, ErrNotPair)
 	}
 }
 
@@ -214,7 +214,7 @@ func TestCollateralCollateralReleaser(t *testing.T) {
 	}
 	var expectedError error
 	if _, err := c.CollateralReleaser(); !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 }
 
@@ -241,41 +241,41 @@ func TestCollateralReserve(t *testing.T) {
 	var expectedError error
 	err := c.Reserve(decimal.NewFromInt(1), gctorder.Long)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 	if !c.collateral.reserved.Equal(decimal.NewFromInt(1)) {
-		t.Errorf("recevied '%v' expected '%v'", c.collateral.reserved, decimal.NewFromInt(1))
+		t.Errorf("received '%v' expected '%v'", c.collateral.reserved, decimal.NewFromInt(1))
 	}
 	if !c.collateral.available.Equal(decimal.NewFromInt(1336)) {
-		t.Errorf("recevied '%v' expected '%v'", c.collateral.available, decimal.NewFromInt(1336))
+		t.Errorf("received '%v' expected '%v'", c.collateral.available, decimal.NewFromInt(1336))
 	}
 
 	err = c.Reserve(decimal.NewFromInt(1), gctorder.Short)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 	if !c.collateral.reserved.Equal(decimal.NewFromInt(2)) {
-		t.Errorf("recevied '%v' expected '%v'", c.collateral.reserved, decimal.NewFromInt(2))
+		t.Errorf("received '%v' expected '%v'", c.collateral.reserved, decimal.NewFromInt(2))
 	}
 	if !c.collateral.available.Equal(decimal.NewFromInt(1335)) {
-		t.Errorf("recevied '%v' expected '%v'", c.collateral.available, decimal.NewFromInt(1335))
+		t.Errorf("received '%v' expected '%v'", c.collateral.available, decimal.NewFromInt(1335))
 	}
 
 	err = c.Reserve(decimal.NewFromInt(2), gctorder.ClosePosition)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 	if !c.collateral.reserved.Equal(decimal.NewFromInt(4)) {
-		t.Errorf("recevied '%v' expected '%v'", c.collateral.reserved, decimal.Zero)
+		t.Errorf("received '%v' expected '%v'", c.collateral.reserved, decimal.Zero)
 	}
 	if !c.collateral.available.Equal(decimal.NewFromInt(1333)) {
-		t.Errorf("recevied '%v' expected '%v'", c.collateral.available, decimal.NewFromInt(1333))
+		t.Errorf("received '%v' expected '%v'", c.collateral.available, decimal.NewFromInt(1333))
 	}
 
 	expectedError = errCannotAllocate
 	err = c.Reserve(decimal.NewFromInt(2), gctorder.Buy)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 }
 
@@ -293,10 +293,10 @@ func TestCollateralLiquidate(t *testing.T) {
 	}
 	c.Liquidate()
 	if !c.collateral.available.Equal(decimal.Zero) {
-		t.Errorf("recevied '%v' expected '%v'", c.collateral.available, decimal.Zero)
+		t.Errorf("received '%v' expected '%v'", c.collateral.available, decimal.Zero)
 	}
 	if !c.contract.available.Equal(decimal.Zero) {
-		t.Errorf("recevied '%v' expected '%v'", c.contract.available, decimal.Zero)
+		t.Errorf("received '%v' expected '%v'", c.contract.available, decimal.Zero)
 	}
 }
 
@@ -306,6 +306,6 @@ func TestCollateralCurrentHoldings(t *testing.T) {
 		contract: &Item{available: decimal.NewFromInt(1337)},
 	}
 	if !c.CurrentHoldings().Equal(decimal.NewFromInt(1337)) {
-		t.Errorf("recevied '%v' expected '%v'", c.CurrentHoldings(), decimal.NewFromInt(1337))
+		t.Errorf("received '%v' expected '%v'", c.CurrentHoldings(), decimal.NewFromInt(1337))
 	}
 }

backtester/funding/funding_test.go

@@ -595,7 +595,7 @@ func TestFundingLiquidate(t *testing.T) {
 	f := FundManager{}
 	err := f.Liquidate(nil)
 	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("recevied '%v' expected '%v'", err, gctcommon.ErrNilPointer)
+		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
 	}
 	f.items = append(f.items, &Item{
 		exchange:  "test",
@@ -612,7 +612,7 @@ func TestFundingLiquidate(t *testing.T) {
 		},
 	})
 	if !errors.Is(err, nil) {
-		t.Errorf("recevied '%v' expected '%v'", err, nil)
+		t.Errorf("received '%v' expected '%v'", err, nil)
 	}
 	if !f.items[0].available.IsZero() {
 		t.Errorf("received '%v' expected '%v'", f.items[0].available, "0")
@@ -624,7 +624,7 @@ func TestHasExchangeBeenLiquidated(t *testing.T) {
 	f := FundManager{}
 	err := f.Liquidate(nil)
 	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("recevied '%v' expected '%v'", err, gctcommon.ErrNilPointer)
+		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
 	}
 	f.items = append(f.items, &Item{
 		exchange:  "test",
@@ -641,7 +641,7 @@ func TestHasExchangeBeenLiquidated(t *testing.T) {
 	}
 	err = f.Liquidate(ev)
 	if !errors.Is(err, nil) {
-		t.Errorf("recevied '%v' expected '%v'", err, nil)
+		t.Errorf("received '%v' expected '%v'", err, nil)
 	}
 	if !f.items[0].available.IsZero() {
 		t.Errorf("received '%v' expected '%v'", f.items[0].available, "0")
@@ -710,16 +710,16 @@ func TestRealisePNL(t *testing.T) {
 	var expectedError error
 	err := f.RealisePNL("test", asset.Futures, currency.BTC, decimal.NewFromInt(1))
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 	if !f.items[0].available.Equal(decimal.NewFromInt(1337)) {
-		t.Errorf("recevied '%v' expected '%v'", f.items[0].available, decimal.NewFromInt(1337))
+		t.Errorf("received '%v' expected '%v'", f.items[0].available, decimal.NewFromInt(1337))
 	}
 
 	expectedError = ErrFundsNotFound
 	err = f.RealisePNL("test2", asset.Futures, currency.BTC, decimal.NewFromInt(1))
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 }
 
@@ -742,18 +742,18 @@ func TestCreateCollateral(t *testing.T) {
 	var expectedError error
 	_, err := CreateCollateral(collat, contract)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 
 	expectedError = gctcommon.ErrNilPointer
 	_, err = CreateCollateral(nil, contract)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 
 	_, err = CreateCollateral(collat, nil)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 }
 
@@ -763,7 +763,7 @@ func TestUpdateCollateral(t *testing.T) {
 	expectedError := common.ErrNilEvent
 	err := f.UpdateCollateralForEvent(nil, false)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 
 	ev := &signal.Signal{
@@ -791,7 +791,7 @@ func TestUpdateCollateral(t *testing.T) {
 	expectedError = nil
 	err = f.UpdateCollateralForEvent(ev, false)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 
 	expectedError = gctcommon.ErrNotYetImplemented
@@ -804,7 +804,7 @@ func TestUpdateCollateral(t *testing.T) {
 	})
 	err = f.UpdateCollateralForEvent(ev, false)
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 }
 

backtester/funding/spotpair_test.go

@@ -263,7 +263,7 @@ func TestGetPairReader(t *testing.T) {
 	var expectedError error
 	ip, err := p.GetPairReader()
 	if !errors.Is(err, expectedError) {
-		t.Errorf("recevied '%v' expected '%v'", err, expectedError)
+		t.Errorf("received '%v' expected '%v'", err, expectedError)
 	}
 	if ip != p {
 		t.Error("expected the same thing")
@@ -276,7 +276,7 @@ func TestGetCollateralReader(t *testing.T) {
 		base: &Item{exchange: "hello"},
 	}
 	if _, err := p.GetCollateralReader(); !errors.Is(err, ErrNotCollateral) {
-		t.Errorf("recevied '%v' expected '%v'", err, ErrNotCollateral)
+		t.Errorf("received '%v' expected '%v'", err, ErrNotCollateral)
 	}
 }
 
@@ -316,7 +316,7 @@ func TestPairReleaser(t *testing.T) {
 		base: &Item{exchange: "hello"},
 	}
 	if _, err := p.PairReleaser(); !errors.Is(err, nil) {
-		t.Errorf("recevied '%v' expected '%v'", err, nil)
+		t.Errorf("received '%v' expected '%v'", err, nil)
 	}
 }
 
@@ -326,7 +326,7 @@ func TestCollateralReleaser(t *testing.T) {
 		base: &Item{exchange: "hello"},
 	}
 	if _, err := p.CollateralReleaser(); !errors.Is(err, ErrNotCollateral) {
-		t.Errorf("recevied '%v' expected '%v'", err, ErrNotCollateral)
+		t.Errorf("received '%v' expected '%v'", err, ErrNotCollateral)
 	}
 }
 

backtester/funding/trackingcurrencies/trackingcurrencies_test.go

@@ -133,7 +133,7 @@ func TestFindMatchingUSDPairs(t *testing.T) {
 			expectedErr:    errNoMatchingPairUSDFound,
 		},
 		{
-			description:    "currency doesnt exist in available pairs",
+			description:    "currency doesn't exist in available pairs",
 			initialPair:    currency.NewPair(currency.BTC, currency.LTC),
 			availablePairs: &currency.PairStore{Available: currency.Pairs{currency.NewPair(currency.BTC, currency.DOGE)}},
 			basePair:       currency.EMPTYPAIR,

backtester/report/report_types.go

@@ -13,7 +13,7 @@ import (
 	"github.com/thrasher-corp/gocryptotrader/exchanges/order"
 )
 
-// lightweight charts can ony render 1100 candles
+// lightweight charts can only render 1100 candles
 const maxChartLimit = 1100
 
 var (