Currency: Add additional functionality, refactor and improvements (#881)

* currency: Add method to derive pair * currency: Add method to lower entire charset but used the slice copy and returned that. This will change the original, just gotta see if this is an issue, but the slice usually goes out of scope anyway. * currency/pairs: add filter method * currency: add function to derive select currencies from currency pairs * currency/engine: slight adjustments * currency: fix linter issue also shift burden of proof to caller instead of repair, more performant. * currency: more linter * pairs: optimize; reduce allocs/op and B/op * currency: Add in function 'NewPairsFromString' for testing purposes * currency: don't suppress error * currency: stop panic on empty currency code * currency: Add helper method to match currencies between exchanges * currency: fixed my bad spelling * currency: Implement stable coin checks, refactored base code methods, optimized upper and lower case strings for currency code/pairs * currency: add pairs method to derive stable coins from internal list. * Currency: Cleanup, fix tests. * engine/exchanges/currency: fix whoops * Currency: force govet no copy on Item datatype * Currency: fix naughty linter issues * exchange: revert change * currency/config: fix config upgrade mistake * currency: re-implement currency sub-systems * *RetrieveConfigCurrencyPairs removed *CheckCurrencyConfigValues to only provide warnings, add additional support when, disable when support is lost or not available and set default values. *Drop Cryptocurrencies from configuration as this is not needed. *Drop REST Poll delay field as this was unused. *Update default values for currencyFileUpdateDuration & foreignExchangeUpdateDuration. *Allow Role to be marshalled for file type. *Refactor RunUpdater to verify and check config values and set default running foreign exchange provider. * currency: cleanup * currency: change match -> equal for comparison which is more of a standard and little easier to find * currency: address nits * currency: fix whoops * currency: Add some more pairs methods * currency: linter issues * currency: RM unused field * currency: rm verbose * currency: fix word * currency: gocritic * currency: fix another whoopsie * example_config: default to show log system name * Currency: Force all support packages to use Equal method for comparison as there is a small comparison bug when checking upper and lower casing, this has a more of a pronounced impact between exchanges and client instances of currency generation * currency: fix log name * ordermanager: fix potential panic * currency: small optim. * engine: display correct bool and force shutdown * currency: add function and fix regression * Change ConvertCurrency -> ConvertFiat to be more precise * ADD GetForeignExchangeRate to get specific exchange rate for fiat pair * Fix currency display and formatting regression and tied in with config.Currency fields * engine: fix tests * currency: return the amount when no conversion needs to take place * currency: reduce method name * currency: Address nits glorious nits * currency: fix linter * currency: addr nits * currency: check underlying role in test * gct: change to EMPTYCODE and EMPTYPAIR across codebase * currency: fix nits * currency: this fixes test race but this issue has not been resolved. Please see: https://trello.com/c/54eizOIo/143-currency-package-upgrades * currency: Add temp dir for testing * Update engine/engine.go Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io> * documentation: update and regen * currency: Address niterinos * currency: Add test case for config upgrade when falling over to exchange rate host as default from exchangeRates provider * currency: addr nits * currency: fix whoops Co-authored-by: Ryan O'Hara-Reid <ryan.oharareid@thrasher.io> Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io>
2026-06-05 15:10:59 +00:00 · 2022-02-17 16:24:57 +11:00
parent 2f353a78f8
commit 11da520dc8
102 changed files with 5199 additions and 3095 deletions
--- a/engine/currency_state_manager_test.go
+++ b/engine/currency_state_manager_test.go
@@ -240,7 +240,7 @@ func TestGetAllRPC(t *testing.T) {

 func TestCanWithdrawRPC(t *testing.T) {
 	t.Parallel()
-	_, err := (*CurrencyStateManager)(nil).CanWithdrawRPC("", currency.Code{}, "")
+	_, err := (*CurrencyStateManager)(nil).CanWithdrawRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, ErrSubSystemNotStarted) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
 	}
@@ -248,7 +248,7 @@ func TestCanWithdrawRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
-	}).CanWithdrawRPC("", currency.Code{}, "")
+	}).CanWithdrawRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, errManager) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
 	}
@@ -256,7 +256,7 @@ func TestCanWithdrawRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
-	}).CanWithdrawRPC("", currency.Code{}, "")
+	}).CanWithdrawRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, errExchange) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
 	}
@@ -264,7 +264,7 @@ func TestCanWithdrawRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{},
-	}).CanWithdrawRPC("", currency.Code{}, "")
+	}).CanWithdrawRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, nil) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, nil)
 	}
@@ -272,7 +272,7 @@ func TestCanWithdrawRPC(t *testing.T) {

 func TestCanDepositRPC(t *testing.T) {
 	t.Parallel()
-	_, err := (*CurrencyStateManager)(nil).CanDepositRPC("", currency.Code{}, "")
+	_, err := (*CurrencyStateManager)(nil).CanDepositRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, ErrSubSystemNotStarted) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
 	}
@@ -280,7 +280,7 @@ func TestCanDepositRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
-	}).CanDepositRPC("", currency.Code{}, "")
+	}).CanDepositRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, errManager) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
 	}
@@ -288,7 +288,7 @@ func TestCanDepositRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
-	}).CanDepositRPC("", currency.Code{}, "")
+	}).CanDepositRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, errExchange) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
 	}
@@ -296,7 +296,7 @@ func TestCanDepositRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{},
-	}).CanDepositRPC("", currency.Code{}, "")
+	}).CanDepositRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, nil) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, nil)
 	}
@@ -304,7 +304,7 @@ func TestCanDepositRPC(t *testing.T) {

 func TestCanTradeRPC(t *testing.T) {
 	t.Parallel()
-	_, err := (*CurrencyStateManager)(nil).CanTradeRPC("", currency.Code{}, "")
+	_, err := (*CurrencyStateManager)(nil).CanTradeRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, ErrSubSystemNotStarted) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
 	}
@@ -312,7 +312,7 @@ func TestCanTradeRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
-	}).CanTradeRPC("", currency.Code{}, "")
+	}).CanTradeRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, errManager) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
 	}
@@ -320,7 +320,7 @@ func TestCanTradeRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
-	}).CanTradeRPC("", currency.Code{}, "")
+	}).CanTradeRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, errExchange) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
 	}
@@ -328,7 +328,7 @@ func TestCanTradeRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{},
-	}).CanTradeRPC("", currency.Code{}, "")
+	}).CanTradeRPC("", currency.EMPTYCODE, "")
 	if !errors.Is(err, nil) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, nil)
 	}
@@ -336,7 +336,7 @@ func TestCanTradeRPC(t *testing.T) {

 func TestCanTradePairRPC(t *testing.T) {
 	t.Parallel()
-	_, err := (*CurrencyStateManager)(nil).CanTradePairRPC("", currency.Pair{}, "")
+	_, err := (*CurrencyStateManager)(nil).CanTradePairRPC("", currency.EMPTYPAIR, "")
 	if !errors.Is(err, ErrSubSystemNotStarted) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
 	}
@@ -344,7 +344,7 @@ func TestCanTradePairRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
-	}).CanTradePairRPC("", currency.Pair{}, "")
+	}).CanTradePairRPC("", currency.EMPTYPAIR, "")
 	if !errors.Is(err, errManager) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
 	}
@@ -352,7 +352,7 @@ func TestCanTradePairRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
-	}).CanTradePairRPC("", currency.Pair{}, "")
+	}).CanTradePairRPC("", currency.EMPTYPAIR, "")
 	if !errors.Is(err, errExchange) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
 	}
@@ -360,7 +360,7 @@ func TestCanTradePairRPC(t *testing.T) {
 	_, err = (&CurrencyStateManager{
 		started:          1,
 		iExchangeManager: &fakeExchangeManagerino{},
-	}).CanTradePairRPC("", currency.Pair{}, "")
+	}).CanTradePairRPC("", currency.EMPTYPAIR, "")
 	if !errors.Is(err, nil) {
 		t.Fatalf("received: '%v' but expected: '%v'", err, nil)
 	}
--- a/engine/engine.go
+++ b/engine/engine.go
@@ -15,7 +15,6 @@ import (
 	"github.com/thrasher-corp/gocryptotrader/common"
 	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/currency"
-	"github.com/thrasher-corp/gocryptotrader/currency/coinmarketcap"
 	"github.com/thrasher-corp/gocryptotrader/dispatch"
 	exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
@@ -146,40 +145,44 @@ func loadConfigWithSettings(settings *Settings, flagSet map[string]bool) (*confi
 	return conf, conf.CheckConfig()
 }

+// FlagSet defines set flags from command line args for comparison methods
+type FlagSet map[string]bool
+
+// WithBool checks the supplied flag. If set it will overide the config boolean
+// value as a command line takes precedence. If not set will fall back to config
+// options.
+func (f FlagSet) WithBool(key string, flagValue *bool, configValue bool) {
+	isSet := f[key]
+	*flagValue = !isSet && configValue || isSet && *flagValue
+}
+
 // validateSettings validates and sets all bot settings
-func validateSettings(b *Engine, s *Settings, flagSet map[string]bool) {
+func validateSettings(b *Engine, s *Settings, flagSet FlagSet) {
 	b.Settings = *s

-	b.Settings.EnableDataHistoryManager = (flagSet["datahistorymanager"] && b.Settings.EnableDatabaseManager) || b.Config.DataHistoryManager.Enabled
+	flagSet.WithBool("coinmarketcap", &b.Settings.EnableCoinmarketcapAnalysis, b.Config.Currency.CryptocurrencyProvider.Enabled)

-	b.Settings.EnableCurrencyStateManager = (flagSet["currencystatemanager"] &&
-		b.Settings.EnableCurrencyStateManager) ||
-		b.Config.CurrencyStateManager.Enabled != nil &&
-			*b.Config.CurrencyStateManager.Enabled
+	flagSet.WithBool("currencyconverter", &b.Settings.EnableCurrencyConverter, b.Config.Currency.ForexProviders.IsEnabled("currencyconverter"))

-	b.Settings.EnableGCTScriptManager = b.Settings.EnableGCTScriptManager &&
-		(flagSet["gctscriptmanager"] || b.Config.GCTScript.Enabled)
+	flagSet.WithBool("currencylayer", &b.Settings.EnableCurrencyLayer, b.Config.Currency.ForexProviders.IsEnabled("currencylayer"))
+	flagSet.WithBool("exchangerates", &b.Settings.EnableExchangeRates, b.Config.Currency.ForexProviders.IsEnabled("exchangerates"))
+	flagSet.WithBool("fixer", &b.Settings.EnableFixer, b.Config.Currency.ForexProviders.IsEnabled("fixer"))
+	flagSet.WithBool("openexchangerates", &b.Settings.EnableOpenExchangeRates, b.Config.Currency.ForexProviders.IsEnabled("openexchangerates"))
+	flagSet.WithBool("exchangeratehost", &b.Settings.EnableExchangeRateHost, b.Config.Currency.ForexProviders.IsEnabled("exchangeratehost"))
+
+	flagSet.WithBool("datahistorymanager", &b.Settings.EnableDataHistoryManager, b.Config.DataHistoryManager.Enabled)
+	flagSet.WithBool("currencystatemanager", &b.Settings.EnableCurrencyStateManager, b.Config.CurrencyStateManager.Enabled != nil && *b.Config.CurrencyStateManager.Enabled)
+	flagSet.WithBool("gctscriptmanager", &b.Settings.EnableGCTScriptManager, b.Config.GCTScript.Enabled)

 	if b.Settings.EnablePortfolioManager &&
 		b.Settings.PortfolioManagerDelay <= 0 {
 		b.Settings.PortfolioManagerDelay = PortfolioSleepDelay
 	}

-	if !flagSet["grpc"] {
-		b.Settings.EnableGRPC = b.Config.RemoteControl.GRPC.Enabled
-	}
-
-	if !flagSet["grpcproxy"] {
-		b.Settings.EnableGRPCProxy = b.Config.RemoteControl.GRPC.GRPCProxyEnabled
-	}
-
-	if !flagSet["websocketrpc"] {
-		b.Settings.EnableWebsocketRPC = b.Config.RemoteControl.WebsocketRPC.Enabled
-	}
-
-	if !flagSet["deprecatedrpc"] {
-		b.Settings.EnableDeprecatedRPC = b.Config.RemoteControl.DeprecatedRPC.Enabled
-	}
+	flagSet.WithBool("grpc", &b.Settings.EnableGRPC, b.Config.RemoteControl.GRPC.Enabled)
+	flagSet.WithBool("grpcproxy", &b.Settings.EnableGRPCProxy, b.Config.RemoteControl.GRPC.GRPCProxyEnabled)
+	flagSet.WithBool("websocketrpc", &b.Settings.EnableWebsocketRPC, b.Config.RemoteControl.WebsocketRPC.Enabled)
+	flagSet.WithBool("deprecatedrpc", &b.Settings.EnableDeprecatedRPC, b.Config.RemoteControl.DeprecatedRPC.Enabled)

 	if flagSet["maxvirtualmachines"] {
 		maxMachines := uint8(b.Settings.MaxVirtualMachines)
@@ -250,7 +253,7 @@ func PrintSettings(s *Settings) {
 	gctlog.Debugf(gctlog.Global, "\t Enable dry run mode: %v", s.EnableDryRun)
 	gctlog.Debugf(gctlog.Global, "\t Enable all exchanges: %v", s.EnableAllExchanges)
 	gctlog.Debugf(gctlog.Global, "\t Enable all pairs: %v", s.EnableAllPairs)
-	gctlog.Debugf(gctlog.Global, "\t Enable coinmarketcap analysis: %v", s.EnableCoinmarketcapAnalysis)
+	gctlog.Debugf(gctlog.Global, "\t Enable CoinMarketCap analysis: %v", s.EnableCoinmarketcapAnalysis)
 	gctlog.Debugf(gctlog.Global, "\t Enable portfolio manager: %v", s.EnablePortfolioManager)
 	gctlog.Debugf(gctlog.Global, "\t Enable data history manager: %v", s.EnableDataHistoryManager)
 	gctlog.Debugf(gctlog.Global, "\t Enable currency state manager: %v", s.EnableCurrencyStateManager)
@@ -273,16 +276,17 @@ func PrintSettings(s *Settings) {
 	gctlog.Debugf(gctlog.Global, "\t Dispatch package jobs limit: %d", s.DispatchJobsLimit)
 	gctlog.Debugf(gctlog.Global, "- EXCHANGE SYNCER SETTINGS:\n")
 	gctlog.Debugf(gctlog.Global, "\t Exchange sync continuously: %v\n", s.SyncContinuously)
-	gctlog.Debugf(gctlog.Global, "\t Exchange sync workers: %v\n", s.SyncWorkers)
+	gctlog.Debugf(gctlog.Global, "\t Exchange sync workers count: %v\n", s.SyncWorkersCount)
 	gctlog.Debugf(gctlog.Global, "\t Enable ticker syncing: %v\n", s.EnableTickerSyncing)
 	gctlog.Debugf(gctlog.Global, "\t Enable orderbook syncing: %v\n", s.EnableOrderbookSyncing)
 	gctlog.Debugf(gctlog.Global, "\t Enable trade syncing: %v\n", s.EnableTradeSyncing)
 	gctlog.Debugf(gctlog.Global, "\t Exchange REST sync timeout: %v\n", s.SyncTimeoutREST)
 	gctlog.Debugf(gctlog.Global, "\t Exchange Websocket sync timeout: %v\n", s.SyncTimeoutWebsocket)
 	gctlog.Debugf(gctlog.Global, "- FOREX SETTINGS:")
-	gctlog.Debugf(gctlog.Global, "\t Enable currency converter: %v", s.EnableCurrencyConverter)
-	gctlog.Debugf(gctlog.Global, "\t Enable currency layer: %v", s.EnableCurrencyLayer)
-	gctlog.Debugf(gctlog.Global, "\t Enable fixer: %v", s.EnableFixer)
+	gctlog.Debugf(gctlog.Global, "\t Enable Currency Converter: %v", s.EnableCurrencyConverter)
+	gctlog.Debugf(gctlog.Global, "\t Enable Currency Layer: %v", s.EnableCurrencyLayer)
+	gctlog.Debugf(gctlog.Global, "\t Enable ExchangeRatesAPI.io: %v", s.EnableExchangeRates)
+	gctlog.Debugf(gctlog.Global, "\t Enable Fixer: %v", s.EnableFixer)
 	gctlog.Debugf(gctlog.Global, "\t Enable OpenExchangeRates: %v", s.EnableOpenExchangeRates)
 	gctlog.Debugf(gctlog.Global, "\t Enable ExchangeRateHost: %v", s.EnableExchangeRateHost)
 	gctlog.Debugf(gctlog.Global, "- EXCHANGE SETTINGS:")
@@ -407,32 +411,20 @@ func (bot *Engine) Start() error {
 			}
 		}
 	}
-	if bot.Settings.EnableCoinmarketcapAnalysis ||
-		bot.Settings.EnableCurrencyConverter ||
-		bot.Settings.EnableCurrencyLayer ||
-		bot.Settings.EnableFixer ||
-		bot.Settings.EnableOpenExchangeRates ||
-		bot.Settings.EnableExchangeRateHost {
-		err = currency.RunStorageUpdater(currency.BotOverrides{
-			Coinmarketcap:       bot.Settings.EnableCoinmarketcapAnalysis,
-			FxCurrencyConverter: bot.Settings.EnableCurrencyConverter,
-			FxCurrencyLayer:     bot.Settings.EnableCurrencyLayer,
-			FxFixer:             bot.Settings.EnableFixer,
-			FxOpenExchangeRates: bot.Settings.EnableOpenExchangeRates,
-			FxExchangeRateHost:  bot.Settings.EnableExchangeRateHost,
-		},
-			&currency.MainConfiguration{
-				ForexProviders:         bot.Config.GetForexProviders(),
-				CryptocurrencyProvider: coinmarketcap.Settings(bot.Config.Currency.CryptocurrencyProvider),
-				Cryptocurrencies:       bot.Config.Currency.Cryptocurrencies,
-				FiatDisplayCurrency:    bot.Config.Currency.FiatDisplayCurrency,
-				CurrencyDelay:          bot.Config.Currency.CurrencyFileUpdateDuration,
-				FxRateDelay:            bot.Config.Currency.ForeignExchangeUpdateDuration,
-			},
-			bot.Settings.DataDir)
-		if err != nil {
-			gctlog.Errorf(gctlog.Global, "ExchangeSettings updater system failed to start %s", err)
-		}
+
+	err = currency.RunStorageUpdater(currency.BotOverrides{
+		Coinmarketcap:     bot.Settings.EnableCoinmarketcapAnalysis,
+		CurrencyConverter: bot.Settings.EnableCurrencyConverter,
+		CurrencyLayer:     bot.Settings.EnableCurrencyLayer,
+		ExchangeRates:     bot.Settings.EnableExchangeRates,
+		Fixer:             bot.Settings.EnableFixer,
+		OpenExchangeRates: bot.Settings.EnableOpenExchangeRates,
+		ExchangeRateHost:  bot.Settings.EnableExchangeRateHost,
+	},
+		&bot.Config.Currency,
+		bot.Settings.DataDir)
+	if err != nil {
+		gctlog.Errorf(gctlog.Global, "ExchangeSettings updater system failed to start %s", err)
 	}

 	if bot.Settings.EnableGRPC {
@@ -524,15 +516,17 @@ func (bot *Engine) Start() error {
 	}

 	if bot.Settings.EnableExchangeSyncManager {
-		exchangeSyncCfg := &Config{
-			SyncTicker:           bot.Settings.EnableTickerSyncing,
-			SyncOrderbook:        bot.Settings.EnableOrderbookSyncing,
-			SyncTrades:           bot.Settings.EnableTradeSyncing,
-			SyncContinuously:     bot.Settings.SyncContinuously,
-			NumWorkers:           bot.Settings.SyncWorkers,
-			Verbose:              bot.Settings.Verbose,
-			SyncTimeoutREST:      bot.Settings.SyncTimeoutREST,
-			SyncTimeoutWebsocket: bot.Settings.SyncTimeoutWebsocket,
+		exchangeSyncCfg := &SyncManagerConfig{
+			SynchronizeTicker:       bot.Settings.EnableTickerSyncing,
+			SynchronizeOrderbook:    bot.Settings.EnableOrderbookSyncing,
+			SynchronizeTrades:       bot.Settings.EnableTradeSyncing,
+			SynchronizeContinuously: bot.Settings.SyncContinuously,
+			TimeoutREST:             bot.Settings.SyncTimeoutREST,
+			TimeoutWebsocket:        bot.Settings.SyncTimeoutWebsocket,
+			NumWorkers:              bot.Settings.SyncWorkersCount,
+			Verbose:                 bot.Settings.Verbose,
+			FiatDisplayCurrency:     bot.Config.Currency.FiatDisplayCurrency,
+			PairFormatDisplay:       bot.Config.Currency.CurrencyPairFormat,
 		}

 		bot.currencyPairSyncer, err = setupSyncManager(
@@ -692,15 +686,8 @@ func (bot *Engine) Stop() {
 		}
 	}

-	if bot.Settings.EnableCoinmarketcapAnalysis ||
-		bot.Settings.EnableCurrencyConverter ||
-		bot.Settings.EnableCurrencyLayer ||
-		bot.Settings.EnableFixer ||
-		bot.Settings.EnableOpenExchangeRates ||
-		bot.Settings.EnableExchangeRateHost {
-		if err := currency.ShutdownStorageUpdater(); err != nil {
-			gctlog.Errorf(gctlog.Global, "ExchangeSettings storage system. Error: %v", err)
-		}
+	if err := currency.ShutdownStorageUpdater(); err != nil {
+		gctlog.Errorf(gctlog.Global, "ExchangeSettings storage system. Error: %v", err)
 	}

 	if !bot.Settings.EnableDryRun {
--- a/engine/engine_test.go
+++ b/engine/engine_test.go
@@ -93,7 +93,7 @@ func TestStartStopDoesNotCausePanic(t *testing.T) {
 		DataDir:      tempDir,
 	}, nil)
 	if err != nil {
-		t.Error(err)
+		t.Fatal(err)
 	}
 	botOne.Settings.EnableGRPCProxy = false
 	for i := range botOne.Config.Exchanges {
@@ -281,3 +281,41 @@ func TestDryRunParamInteraction(t *testing.T) {
 		t.Error("dryrun should be true and verbose should be true")
 	}
 }
+
+func TestFlagSetWith(t *testing.T) {
+	var isRunning bool
+	flags := make(FlagSet)
+	// Flag not set default to config
+	flags.WithBool("NOT SET", &isRunning, true)
+	if !isRunning {
+		t.Fatalf("received: '%v' but expected: '%v'", isRunning, true)
+	}
+	flags.WithBool("NOT SET", &isRunning, false)
+	if isRunning {
+		t.Fatalf("received: '%v' but expected: '%v'", isRunning, false)
+	}
+
+	flags["IS SET"] = true
+	isRunning = true
+	// Flag set true which will overide config
+	flags.WithBool("IS SET", &isRunning, true)
+	if !isRunning {
+		t.Fatalf("received: '%v' but expected: '%v'", isRunning, true)
+	}
+	flags.WithBool("IS SET", &isRunning, false)
+	if !isRunning {
+		t.Fatalf("received: '%v' but expected: '%v'", isRunning, true)
+	}
+
+	flags["IS SET"] = true
+	isRunning = false
+	// Flag set false which will overide config
+	flags.WithBool("IS SET", &isRunning, true)
+	if isRunning {
+		t.Fatalf("received: '%v' but expected: '%v'", isRunning, false)
+	}
+	flags.WithBool("IS SET", &isRunning, false)
+	if isRunning {
+		t.Fatalf("received: '%v' but expected: '%v'", isRunning, false)
+	}
+}
--- a/engine/engine_types.go
+++ b/engine/engine_types.go
@@ -44,7 +44,7 @@ type Settings struct {
 	EnableTickerSyncing    bool
 	EnableOrderbookSyncing bool
 	EnableTradeSyncing     bool
-	SyncWorkers            int
+	SyncWorkersCount       int
 	SyncContinuously       bool
 	SyncTimeoutREST        time.Duration
 	SyncTimeoutWebsocket   time.Duration
@@ -52,6 +52,7 @@ type Settings struct {
 	// Forex settings
 	EnableCurrencyConverter bool
 	EnableCurrencyLayer     bool
+	EnableExchangeRates     bool
 	EnableFixer             bool
 	EnableOpenExchangeRates bool
 	EnableExchangeRateHost  bool
--- a/engine/helpers.go
+++ b/engine/helpers.go
@@ -184,15 +184,16 @@ func (bot *Engine) SetSubsystem(subSystemName string, enable bool) error {
 	case SyncManagerName:
 		if enable {
 			if bot.currencyPairSyncer == nil {
-				exchangeSyncCfg := &Config{
-					SyncTicker:           bot.Settings.EnableTickerSyncing,
-					SyncOrderbook:        bot.Settings.EnableOrderbookSyncing,
-					SyncTrades:           bot.Settings.EnableTradeSyncing,
-					SyncContinuously:     bot.Settings.SyncContinuously,
-					NumWorkers:           bot.Settings.SyncWorkers,
-					Verbose:              bot.Settings.Verbose,
-					SyncTimeoutREST:      bot.Settings.SyncTimeoutREST,
-					SyncTimeoutWebsocket: bot.Settings.SyncTimeoutWebsocket,
+				exchangeSyncCfg := &SyncManagerConfig{
+					SynchronizeTicker:       bot.Settings.EnableTickerSyncing,
+					SynchronizeOrderbook:    bot.Settings.EnableOrderbookSyncing,
+					SynchronizeTrades:       bot.Settings.EnableTradeSyncing,
+					SynchronizeContinuously: bot.Settings.SyncContinuously,
+					TimeoutREST:             bot.Settings.SyncTimeoutREST,
+					TimeoutWebsocket:        bot.Settings.SyncTimeoutWebsocket,
+					NumWorkers:              bot.Settings.SyncWorkersCount,
+					FiatDisplayCurrency:     bot.Config.Currency.FiatDisplayCurrency,
+					Verbose:                 bot.Settings.Verbose,
 				}
 				bot.currencyPairSyncer, err = setupSyncManager(
 					exchangeSyncCfg,
@@ -376,9 +377,9 @@ func (bot *Engine) GetSpecificAvailablePairs(enabledExchangesOnly, fiatPairs, in
 	for x := range supportedPairs {
 		if fiatPairs {
 			if supportedPairs[x].IsCryptoFiatPair() &&
-				!supportedPairs[x].ContainsCurrency(currency.USDT) ||
+				!supportedPairs[x].Contains(currency.USDT) ||
 				(includeUSDT &&
-					supportedPairs[x].ContainsCurrency(currency.USDT) &&
+					supportedPairs[x].Contains(currency.USDT) &&
 					supportedPairs[x].IsCryptoPair()) {
 				if pairList.Contains(supportedPairs[x], false) {
 					continue
@@ -428,18 +429,12 @@ func (bot *Engine) MapCurrenciesByExchange(p currency.Pairs, enabledExchangesOnl
 				continue
 			}

-			result, ok := currencyExchange[exchName]
-			if !ok {
-				var pairs []currency.Pair
-				pairs = append(pairs, p[x])
-				currencyExchange[exchName] = pairs
-			} else {
-				if result.Contains(p[x], false) {
-					continue
-				}
-				result = append(result, p[x])
-				currencyExchange[exchName] = result
+			result := currencyExchange[exchName]
+			if result.Contains(p[x], false) {
+				continue
 			}
+			result = append(result, p[x])
+			currencyExchange[exchName] = result
 		}
 	}
 	return currencyExchange
@@ -468,18 +463,14 @@ func (bot *Engine) GetExchangeNamesByCurrency(p currency.Pair, enabled bool, ass
 func GetRelatableCryptocurrencies(p currency.Pair) currency.Pairs {
 	var pairs currency.Pairs
 	cryptocurrencies := currency.GetCryptocurrencies()
-
 	for x := range cryptocurrencies {
 		newPair := currency.NewPair(p.Base, cryptocurrencies[x])
 		if newPair.IsInvalid() {
 			continue
 		}
-
-		if newPair.Base.Upper() == p.Base.Upper() &&
-			newPair.Quote.Upper() == p.Quote.Upper() {
+		if newPair.Equal(p) {
 			continue
 		}
-
 		if pairs.Contains(newPair, false) {
 			continue
 		}
@@ -496,12 +487,11 @@ func GetRelatableFiatCurrencies(p currency.Pair) currency.Pairs {

 	for x := range fiatCurrencies {
 		newPair := currency.NewPair(p.Base, fiatCurrencies[x])
-		if newPair.Base.Upper() == newPair.Quote.Upper() {
+		if newPair.Base.Equal(newPair.Quote) {
 			continue
 		}

-		if newPair.Base.Upper() == p.Base.Upper() &&
-			newPair.Quote.Upper() == p.Quote.Upper() {
+		if newPair.Equal(p) {
 			continue
 		}

@@ -532,17 +522,17 @@ func GetRelatableCurrencies(p currency.Pair, incOrig, incUSDT bool) currency.Pai
 		}

 		first := currency.GetTranslation(p.Base)
-		if first != p.Base {
+		if !first.Equal(p.Base) {
 			addPair(currency.NewPair(first, p.Quote))

 			second := currency.GetTranslation(p.Quote)
-			if second != p.Quote {
+			if !second.Equal(p.Quote) {
 				addPair(currency.NewPair(first, second))
 			}
 		}

 		second := currency.GetTranslation(p.Quote)
-		if second != p.Quote {
+		if !second.Equal(p.Quote) {
 			addPair(currency.NewPair(p.Base, second))
 		}
 	}
@@ -641,30 +631,17 @@ func (bot *Engine) GetCryptocurrenciesByExchange(exchangeName string, enabledExc
 		}

 		var err error
-		var pairs []currency.Pair
+		var pairs currency.Pairs
 		if enabledPairs {
 			pairs, err = bot.Config.GetEnabledPairs(exchangeName, assetType)
-			if err != nil {
-				return nil, err
-			}
 		} else {
 			pairs, err = bot.Config.GetAvailablePairs(exchangeName, assetType)
-			if err != nil {
-				return nil, err
-			}
 		}
-
-		for y := range pairs {
-			if pairs[y].Base.IsCryptocurrency() &&
-				!common.StringDataCompareInsensitive(cryptocurrencies, pairs[y].Base.String()) {
-				cryptocurrencies = append(cryptocurrencies, pairs[y].Base.String())
-			}
-
-			if pairs[y].Quote.IsCryptocurrency() &&
-				!common.StringDataCompareInsensitive(cryptocurrencies, pairs[y].Quote.String()) {
-				cryptocurrencies = append(cryptocurrencies, pairs[y].Quote.String())
-			}
+		if err != nil {
+			return nil, err
 		}
+		cryptocurrencies = pairs.GetCrypto().Strings()
+		break
 	}
 	return cryptocurrencies, nil
 }
@@ -681,7 +658,7 @@ func (bot *Engine) GetCryptocurrencyDepositAddressesByExchange(exchName string)
 	result := bot.GetAllExchangeCryptocurrencyDepositAddresses()
 	r, ok := result[exchName]
 	if !ok {
-		return nil, ErrExchangeNotFound
+		return nil, fmt.Errorf("%s %w", exchName, ErrExchangeNotFound)
 	}
 	return r, nil
 }
@@ -689,7 +666,9 @@ func (bot *Engine) GetCryptocurrencyDepositAddressesByExchange(exchName string)
 // GetExchangeCryptocurrencyDepositAddress returns the cryptocurrency deposit address for a particular
 // exchange
 func (bot *Engine) GetExchangeCryptocurrencyDepositAddress(ctx context.Context, exchName, accountID, chain string, item currency.Code, bypassCache bool) (*deposit.Address, error) {
-	if bot.DepositAddressManager != nil && bot.DepositAddressManager.IsSynced() && !bypassCache {
+	if bot.DepositAddressManager != nil &&
+		bot.DepositAddressManager.IsSynced() &&
+		!bypassCache {
 		resp, err := bot.DepositAddressManager.GetDepositAddressByExchangeAndCurrency(exchName, chain, item)
 		return &resp, err
 	}
--- a/engine/helpers_test.go
+++ b/engine/helpers_test.go
@@ -99,7 +99,7 @@ func CreateTestBot(t *testing.T) *Engine {
 func TestGetSubsystemsStatus(t *testing.T) {
 	m := (&Engine{}).GetSubsystemsStatus()
 	if len(m) != 15 {
-		t.Fatalf("subsystem count is wrong expecting: %d but received: %d", 14, len(m))
+		t.Fatalf("subsystem count is wrong expecting: %d but received: %d", 15, len(m))
 	}
 }

@@ -1029,10 +1029,10 @@ func (f fakeDepositExchange) GetAvailableTransferChains(_ context.Context, c cur
 	if f.ThrowTransferChainError {
 		return nil, errors.New("unable to get available transfer chains")
 	}
-	if c.Match(currency.XRP) {
+	if c.Equal(currency.XRP) {
 		return nil, nil
 	}
-	if c.Match(currency.USDT) {
+	if c.Equal(currency.USDT) {
 		return []string{"sol", "btc", "usdt"}, nil
 	}
 	return []string{"BITCOIN"}, nil
--- a/engine/order_manager.go
+++ b/engine/order_manager.go
@@ -653,8 +653,9 @@ func (m *OrderManager) processOrders() {
 				upsertResponse, err := m.UpsertOrder(&result[z])
 				if err != nil {
 					log.Error(log.OrderMgr, err)
+				} else {
+					requiresProcessing[upsertResponse.OrderDetails.InternalOrderID] = false
 				}
-				requiresProcessing[upsertResponse.OrderDetails.InternalOrderID] = false
 			}
 			if !exchanges[i].GetBase().GetSupportedFeatures().RESTCapabilities.GetOrder {
 				continue
--- a/engine/order_manager_test.go
+++ b/engine/order_manager_test.go
@@ -519,14 +519,14 @@ func TestCancelOrder(t *testing.T) {

 func TestGetOrderInfo(t *testing.T) {
 	m := OrdersSetup(t)
-	_, err := m.GetOrderInfo(context.Background(), "", "", currency.Pair{}, "")
+	_, err := m.GetOrderInfo(context.Background(), "", "", currency.EMPTYPAIR, "")
 	if err == nil {
 		t.Error("Expected error due to empty order")
 	}

 	var result order.Detail
 	result, err = m.GetOrderInfo(context.Background(),
-		testExchange, "1337", currency.Pair{}, "")
+		testExchange, "1337", currency.EMPTYPAIR, "")
 	if err != nil {
 		t.Error(err)
 	}
@@ -535,7 +535,7 @@ func TestGetOrderInfo(t *testing.T) {
 	}

 	result, err = m.GetOrderInfo(context.Background(),
-		testExchange, "1337", currency.Pair{}, "")
+		testExchange, "1337", currency.EMPTYPAIR, "")
 	if err != nil {
 		t.Error(err)
 	}
--- a/engine/portfolio_manager.go
+++ b/engine/portfolio_manager.go
@@ -164,7 +164,7 @@ func (m *portfolioManager) seedExchangeAccountInfo(accounts []account.Holdings)
 			for z := range accounts[x].Accounts[y].Currencies {
 				var update bool
 				for i := range currencies {
-					if accounts[x].Accounts[y].Currencies[z].CurrencyName == currencies[i].CurrencyName {
+					if accounts[x].Accounts[y].Currencies[z].CurrencyName.Equal(currencies[i].CurrencyName) {
 						currencies[i].Hold += accounts[x].Accounts[y].Currencies[z].Hold
 						currencies[i].TotalValue += accounts[x].Accounts[y].Currencies[z].TotalValue
 						update = true
--- a/engine/rpcserver.go
+++ b/engine/rpcserver.go
@@ -559,7 +559,7 @@ func (s *RPCServer) GetAccountInfo(ctx context.Context, r *gctrpc.GetAccountInfo
 		return nil, err
 	}

-	err = checkParams(r.Exchange, exch, assetType, currency.Pair{})
+	err = checkParams(r.Exchange, exch, assetType, currency.EMPTYPAIR)
 	if err != nil {
 		return nil, err
 	}
@@ -584,7 +584,7 @@ func (s *RPCServer) UpdateAccountInfo(ctx context.Context, r *gctrpc.GetAccountI
 		return nil, err
 	}

-	err = checkParams(r.Exchange, exch, assetType, currency.Pair{})
+	err = checkParams(r.Exchange, exch, assetType, currency.EMPTYPAIR)
 	if err != nil {
 		return nil, err
 	}
@@ -627,7 +627,7 @@ func (s *RPCServer) GetAccountInfoStream(r *gctrpc.GetAccountInfoRequest, stream
 		return err
 	}

-	err = checkParams(r.Exchange, exch, assetType, currency.Pair{})
+	err = checkParams(r.Exchange, exch, assetType, currency.EMPTYPAIR)
 	if err != nil {
 		return err
 	}
@@ -832,7 +832,7 @@ func (s *RPCServer) GetForexProviders(_ context.Context, _ *gctrpc.GetForexProvi
 			Name:             providers[x].Name,
 			Enabled:          providers[x].Enabled,
 			Verbose:          providers[x].Verbose,
-			RestPollingDelay: providers[x].RESTPollingDelay.String(),
+			RestPollingDelay: s.Config.Currency.ForeignExchangeUpdateDuration.String(),
 			ApiKey:           providers[x].APIKey,
 			ApiKeyLevel:      int64(providers[x].APIKeyLvl),
 			PrimaryProvider:  providers[x].PrimaryProvider,
@@ -1954,7 +1954,7 @@ func (s *RPCServer) SetExchangePair(_ context.Context, r *gctrpc.SetExchangePair
 		return nil, err
 	}

-	err = checkParams(r.Exchange, exch, a, currency.Pair{})
+	err = checkParams(r.Exchange, exch, a, currency.EMPTYPAIR)
 	if err != nil {
 		return nil, err
 	}
--- a/engine/sync_manager.go
+++ b/engine/sync_manager.go
@@ -42,8 +42,12 @@ var (
 )

 // setupSyncManager starts a new CurrencyPairSyncer
-func setupSyncManager(c *Config, exchangeManager iExchangeManager, remoteConfig *config.RemoteControlConfig, websocketRoutineManagerEnabled bool) (*syncManager, error) {
-	if !c.SyncOrderbook && !c.SyncTicker && !c.SyncTrades {
+func setupSyncManager(c *SyncManagerConfig, exchangeManager iExchangeManager, remoteConfig *config.RemoteControlConfig, websocketRoutineManagerEnabled bool) (*syncManager, error) {
+	if c == nil {
+		return nil, fmt.Errorf("%T %w", c, common.ErrNilPointer)
+	}
+
+	if !c.SynchronizeOrderbook && !c.SynchronizeTicker && !c.SynchronizeTrades {
 		return nil, errNoSyncItemsEnabled
 	}
 	if exchangeManager == nil {
@@ -57,12 +61,24 @@ func setupSyncManager(c *Config, exchangeManager iExchangeManager, remoteConfig
 		c.NumWorkers = DefaultSyncerWorkers
 	}

-	if c.SyncTimeoutREST <= time.Duration(0) {
-		c.SyncTimeoutREST = DefaultSyncerTimeoutREST
+	if c.TimeoutREST <= time.Duration(0) {
+		c.TimeoutREST = DefaultSyncerTimeoutREST
 	}

-	if c.SyncTimeoutWebsocket <= time.Duration(0) {
-		c.SyncTimeoutWebsocket = DefaultSyncerTimeoutWebsocket
+	if c.TimeoutWebsocket <= time.Duration(0) {
+		c.TimeoutWebsocket = DefaultSyncerTimeoutWebsocket
+	}
+
+	if c.FiatDisplayCurrency.IsEmpty() {
+		return nil, fmt.Errorf("FiatDisplayCurrency %w", currency.ErrCurrencyCodeEmpty)
+	}
+
+	if !c.FiatDisplayCurrency.IsFiatCurrency() {
+		return nil, fmt.Errorf("%s %w", c.FiatDisplayCurrency, currency.ErrFiatDisplayCurrencyIsNotFiat)
+	}
+
+	if c.PairFormatDisplay == nil {
+		return nil, fmt.Errorf("%T %w", c.PairFormatDisplay, common.ErrNilPointer)
 	}

 	s := &syncManager{
@@ -70,27 +86,26 @@ func setupSyncManager(c *Config, exchangeManager iExchangeManager, remoteConfig
 		remoteConfig:                   remoteConfig,
 		exchangeManager:                exchangeManager,
 		websocketRoutineManagerEnabled: websocketRoutineManagerEnabled,
+		fiatDisplayCurrency:            c.FiatDisplayCurrency,
+		delimiter:                      c.PairFormatDisplay.Delimiter,
+		uppercase:                      c.PairFormatDisplay.Uppercase,
+		tickerBatchLastRequested:       make(map[string]time.Time),
 	}

-	s.tickerBatchLastRequested = make(map[string]time.Time)
-
 	log.Debugf(log.SyncMgr,
 		"Exchange currency pair syncer config: continuous: %v ticker: %v"+
 			" orderbook: %v trades: %v workers: %v verbose: %v timeout REST: %v"+
 			" timeout Websocket: %v",
-		s.config.SyncContinuously, s.config.SyncTicker, s.config.SyncOrderbook,
-		s.config.SyncTrades, s.config.NumWorkers, s.config.Verbose, s.config.SyncTimeoutREST,
-		s.config.SyncTimeoutWebsocket)
+		s.config.SynchronizeContinuously, s.config.SynchronizeTicker, s.config.SynchronizeOrderbook,
+		s.config.SynchronizeTrades, s.config.NumWorkers, s.config.Verbose, s.config.TimeoutREST,
+		s.config.TimeoutWebsocket)
 	s.inService.Add(1)
 	return s, nil
 }

 // IsRunning safely checks whether the subsystem is running
 func (m *syncManager) IsRunning() bool {
-	if m == nil {
-		return false
-	}
-	return atomic.LoadInt32(&m.started) == 1
+	return m != nil && atomic.LoadInt32(&m.started) == 1
 }

 // Start runs the subsystem
@@ -169,13 +184,13 @@ func (m *syncManager) Start() error {
 					IsUsingREST:      usingREST || !wsAssetSupported,
 					IsUsingWebsocket: usingWebsocket && wsAssetSupported,
 				}
-				if m.config.SyncTicker {
+				if m.config.SynchronizeTicker {
 					c.Ticker = sBase
 				}
-				if m.config.SyncOrderbook {
+				if m.config.SynchronizeOrderbook {
 					c.Orderbook = sBase
 				}
-				if m.config.SyncTrades {
+				if m.config.SynchronizeTrades {
 					c.Trade = sBase
 				}

@@ -199,7 +214,7 @@ func (m *syncManager) Start() error {
 			log.Debugf(log.SyncMgr, "Exchange CurrencyPairSyncer initial sync took %v [%v sync items].",
 				completedTime.Sub(m.initSyncStartTime), createdCounter)

-			if !m.config.SyncContinuously {
+			if !m.config.SynchronizeContinuously {
 				log.Debugln(log.SyncMgr, "Exchange CurrencyPairSyncer stopping.")
 				err := m.Stop()
 				if err != nil {
@@ -210,7 +225,7 @@ func (m *syncManager) Start() error {
 		}
 	}()

-	if atomic.LoadInt32(&m.initSyncCompleted) == 1 && !m.config.SyncContinuously {
+	if atomic.LoadInt32(&m.initSyncCompleted) == 1 && !m.config.SynchronizeContinuously {
 		return nil
 	}

@@ -267,7 +282,7 @@ func (m *syncManager) add(c *currencyPairSyncAgent) {
 	m.mux.Lock()
 	defer m.mux.Unlock()

-	if m.config.SyncTicker {
+	if m.config.SynchronizeTicker {
 		if m.config.Verbose {
 			log.Debugf(log.SyncMgr,
 				"%s: Added ticker sync item %v: using websocket: %v using REST: %v",
@@ -280,7 +295,7 @@ func (m *syncManager) add(c *currencyPairSyncAgent) {
 		}
 	}

-	if m.config.SyncOrderbook {
+	if m.config.SynchronizeOrderbook {
 		if m.config.Verbose {
 			log.Debugf(log.SyncMgr,
 				"%s: Added orderbook sync item %v: using websocket: %v using REST: %v",
@@ -293,7 +308,7 @@ func (m *syncManager) add(c *currencyPairSyncAgent) {
 		}
 	}

-	if m.config.SyncTrades {
+	if m.config.SynchronizeTrades {
 		if m.config.Verbose {
 			log.Debugf(log.SyncMgr,
 				"%s: Added trade sync item %v: using websocket: %v using REST: %v",
@@ -367,15 +382,15 @@ func (m *syncManager) Update(exchangeName string, p currency.Pair, a asset.Item,

 	switch syncType {
 	case SyncItemOrderbook:
-		if !m.config.SyncOrderbook {
+		if !m.config.SynchronizeOrderbook {
 			return nil
 		}
 	case SyncItemTicker:
-		if !m.config.SyncTicker {
+		if !m.config.SynchronizeTicker {
 			return nil
 		}
 	case SyncItemTrade:
-		if !m.config.SyncTrades {
+		if !m.config.SynchronizeTrades {
 			return nil
 		}
 	default:
@@ -517,15 +532,15 @@ func (m *syncManager) worker() {
 								IsUsingWebsocket: usingWebsocket && wsAssetSupported,
 							}

-							if m.config.SyncTicker {
+							if m.config.SynchronizeTicker {
 								c.Ticker = sBase
 							}

-							if m.config.SyncOrderbook {
+							if m.config.SynchronizeOrderbook {
 								c.Orderbook = sBase
 							}

-							if m.config.SyncTrades {
+							if m.config.SynchronizeTrades {
 								c.Trade = sBase
 							}

@@ -542,13 +557,13 @@ func (m *syncManager) worker() {
 						switchedToRest = false
 					}

-					if m.config.SyncOrderbook {
+					if m.config.SynchronizeOrderbook {
 						if !m.isProcessing(exchangeName, c.Pair, c.AssetType, SyncItemOrderbook) {
 							if c.Orderbook.LastUpdated.IsZero() ||
-								(time.Since(c.Orderbook.LastUpdated) > m.config.SyncTimeoutREST && c.Orderbook.IsUsingREST) ||
-								(time.Since(c.Orderbook.LastUpdated) > m.config.SyncTimeoutWebsocket && c.Orderbook.IsUsingWebsocket) {
+								(time.Since(c.Orderbook.LastUpdated) > m.config.TimeoutREST && c.Orderbook.IsUsingREST) ||
+								(time.Since(c.Orderbook.LastUpdated) > m.config.TimeoutWebsocket && c.Orderbook.IsUsingWebsocket) {
 								if c.Orderbook.IsUsingWebsocket {
-									if time.Since(c.Created) < m.config.SyncTimeoutWebsocket {
+									if time.Since(c.Created) < m.config.TimeoutWebsocket {
 										continue
 									}
 									if supportsREST {
@@ -560,7 +575,7 @@ func (m *syncManager) worker() {
 											c.Exchange,
 											m.FormatCurrency(c.Pair).String(),
 											strings.ToUpper(c.AssetType.String()),
-											m.config.SyncTimeoutWebsocket,
+											m.config.TimeoutWebsocket,
 										)
 										switchedToRest = true
 										m.setProcessing(c.Exchange, c.Pair, c.AssetType, SyncItemOrderbook, false)
@@ -586,13 +601,13 @@ func (m *syncManager) worker() {
 							}
 						}

-						if m.config.SyncTicker {
+						if m.config.SynchronizeTicker {
 							if !m.isProcessing(exchangeName, c.Pair, c.AssetType, SyncItemTicker) {
 								if c.Ticker.LastUpdated.IsZero() ||
-									(time.Since(c.Ticker.LastUpdated) > m.config.SyncTimeoutREST && c.Ticker.IsUsingREST) ||
-									(time.Since(c.Ticker.LastUpdated) > m.config.SyncTimeoutWebsocket && c.Ticker.IsUsingWebsocket) {
+									(time.Since(c.Ticker.LastUpdated) > m.config.TimeoutREST && c.Ticker.IsUsingREST) ||
+									(time.Since(c.Ticker.LastUpdated) > m.config.TimeoutWebsocket && c.Ticker.IsUsingWebsocket) {
 									if c.Ticker.IsUsingWebsocket {
-										if time.Since(c.Created) < m.config.SyncTimeoutWebsocket {
+										if time.Since(c.Created) < m.config.TimeoutWebsocket {
 											continue
 										}

@@ -605,7 +620,7 @@ func (m *syncManager) worker() {
 												c.Exchange,
 												m.FormatCurrency(enabledPairs[i]).String(),
 												strings.ToUpper(c.AssetType.String()),
-												m.config.SyncTimeoutWebsocket,
+												m.config.TimeoutWebsocket,
 											)
 											switchedToRest = true
 											m.setProcessing(c.Exchange, c.Pair, c.AssetType, SyncItemTicker, false)
@@ -625,7 +640,7 @@ func (m *syncManager) worker() {
 											}
 											m.mux.Unlock()

-											if batchLastDone.IsZero() || time.Since(batchLastDone) > m.config.SyncTimeoutREST {
+											if batchLastDone.IsZero() || time.Since(batchLastDone) > m.config.TimeoutREST {
 												m.mux.Lock()
 												if m.config.Verbose {
 													log.Debugf(log.SyncMgr, "Initialising %s REST ticker batching", exchangeName)
@@ -666,9 +681,9 @@ func (m *syncManager) worker() {
 							}
 						}

-						if m.config.SyncTrades {
+						if m.config.SynchronizeTrades {
 							if !m.isProcessing(exchangeName, c.Pair, c.AssetType, SyncItemTrade) {
-								if c.Trade.LastUpdated.IsZero() || time.Since(c.Trade.LastUpdated) > m.config.SyncTimeoutREST {
+								if c.Trade.LastUpdated.IsZero() || time.Since(c.Trade.LastUpdated) > m.config.TimeoutREST {
 									m.setProcessing(c.Exchange, c.Pair, c.AssetType, SyncItemTrade, true)
 									err := m.Update(c.Exchange, c.Pair, c.AssetType, SyncItemTrade, nil)
 									if err != nil {
@@ -693,12 +708,14 @@ func printCurrencyFormat(price float64, displayCurrency currency.Code) string {
 	return fmt.Sprintf("%s%.8f", displaySymbol, price)
 }

-func printConvertCurrencyFormat(origCurrency currency.Code, origPrice float64, displayCurrency currency.Code) string {
-	conv, err := currency.ConvertCurrency(origPrice,
-		origCurrency,
-		displayCurrency)
-	if err != nil {
-		log.Errorf(log.SyncMgr, "Failed to convert currency: %s", err)
+func printConvertCurrencyFormat(origPrice float64, origCurrency, displayCurrency currency.Code) string {
+	var conv float64
+	if origPrice > 0 {
+		var err error
+		conv, err = currency.ConvertFiat(origPrice, origCurrency, displayCurrency)
+		if err != nil {
+			log.Errorf(log.SyncMgr, "Failed to convert currency: %s", err)
+		}
 	}

 	displaySymbol, err := currency.GetSymbolByCurrencyName(displayCurrency)
@@ -745,7 +762,7 @@ func (m *syncManager) PrintTickerSummary(result *ticker.Price, protocol string,
 	_ = stats.Add(result.ExchangeName, result.Pair, result.AssetType, result.Last, result.Volume)

 	if result.Pair.Quote.IsFiatCurrency() &&
-		result.Pair.Quote != m.fiatDisplayCurrency &&
+		!result.Pair.Quote.Equal(m.fiatDisplayCurrency) &&
 		!m.fiatDisplayCurrency.IsEmpty() {
 		origCurrency := result.Pair.Quote.Upper()
 		log.Infof(log.Ticker, "%s %s %s %s: TICKER: Last %s Ask %s Bid %s High %s Low %s Volume %.8f",
@@ -753,15 +770,15 @@ func (m *syncManager) PrintTickerSummary(result *ticker.Price, protocol string,
 			protocol,
 			m.FormatCurrency(result.Pair),
 			strings.ToUpper(result.AssetType.String()),
-			printConvertCurrencyFormat(origCurrency, result.Last, m.fiatDisplayCurrency),
-			printConvertCurrencyFormat(origCurrency, result.Ask, m.fiatDisplayCurrency),
-			printConvertCurrencyFormat(origCurrency, result.Bid, m.fiatDisplayCurrency),
-			printConvertCurrencyFormat(origCurrency, result.High, m.fiatDisplayCurrency),
-			printConvertCurrencyFormat(origCurrency, result.Low, m.fiatDisplayCurrency),
+			printConvertCurrencyFormat(result.Last, origCurrency, m.fiatDisplayCurrency),
+			printConvertCurrencyFormat(result.Ask, origCurrency, m.fiatDisplayCurrency),
+			printConvertCurrencyFormat(result.Bid, origCurrency, m.fiatDisplayCurrency),
+			printConvertCurrencyFormat(result.High, origCurrency, m.fiatDisplayCurrency),
+			printConvertCurrencyFormat(result.Low, origCurrency, m.fiatDisplayCurrency),
 			result.Volume)
 	} else {
 		if result.Pair.Quote.IsFiatCurrency() &&
-			result.Pair.Quote == m.fiatDisplayCurrency &&
+			result.Pair.Quote.Equal(m.fiatDisplayCurrency) &&
 			!m.fiatDisplayCurrency.IsEmpty() {
 			log.Infof(log.Ticker, "%s %s %s %s: TICKER: Last %s Ask %s Bid %s High %s Low %s Volume %.8f",
 				result.ExchangeName,
@@ -838,11 +855,15 @@ func (m *syncManager) PrintOrderbookSummary(result *orderbook.Base, protocol str

 	var bidValueResult, askValueResult string
 	switch {
-	case result.Pair.Quote.IsFiatCurrency() && result.Pair.Quote != m.fiatDisplayCurrency && !m.fiatDisplayCurrency.IsEmpty():
+	case result.Pair.Quote.IsFiatCurrency() && !result.Pair.Quote.Equal(m.fiatDisplayCurrency) && !m.fiatDisplayCurrency.IsEmpty():
 		origCurrency := result.Pair.Quote.Upper()
-		bidValueResult = printConvertCurrencyFormat(origCurrency, bidsValue, m.fiatDisplayCurrency)
-		askValueResult = printConvertCurrencyFormat(origCurrency, asksValue, m.fiatDisplayCurrency)
-	case result.Pair.Quote.IsFiatCurrency() && result.Pair.Quote == m.fiatDisplayCurrency && !m.fiatDisplayCurrency.IsEmpty():
+		if bidsValue > 0 {
+			bidValueResult = printConvertCurrencyFormat(bidsValue, origCurrency, m.fiatDisplayCurrency)
+		}
+		if asksValue > 0 {
+			askValueResult = printConvertCurrencyFormat(asksValue, origCurrency, m.fiatDisplayCurrency)
+		}
+	case result.Pair.Quote.IsFiatCurrency() && result.Pair.Quote.Equal(m.fiatDisplayCurrency) && !m.fiatDisplayCurrency.IsEmpty():
 		bidValueResult = printCurrencyFormat(bidsValue, m.fiatDisplayCurrency)
 		askValueResult = printCurrencyFormat(asksValue, m.fiatDisplayCurrency)
 	default:
--- a/engine/sync_manager_test.go
+++ b/engine/sync_manager_test.go
@@ -14,22 +14,42 @@ import (

 func TestSetupSyncManager(t *testing.T) {
 	t.Parallel()
-	_, err := setupSyncManager(&Config{}, nil, nil, false)
+	_, err := setupSyncManager(nil, nil, nil, false)
+	if !errors.Is(err, common.ErrNilPointer) {
+		t.Errorf("error '%v', expected '%v'", err, common.ErrNilPointer)
+	}
+
+	_, err = setupSyncManager(&SyncManagerConfig{}, nil, nil, false)
 	if !errors.Is(err, errNoSyncItemsEnabled) {
 		t.Errorf("error '%v', expected '%v'", err, errNoSyncItemsEnabled)
 	}

-	_, err = setupSyncManager(&Config{SyncTrades: true}, nil, nil, false)
+	_, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true}, nil, nil, false)
 	if !errors.Is(err, errNilExchangeManager) {
 		t.Errorf("error '%v', expected '%v'", err, errNilExchangeManager)
 	}

-	_, err = setupSyncManager(&Config{SyncTrades: true}, &ExchangeManager{}, nil, false)
+	_, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true}, &ExchangeManager{}, nil, false)
 	if !errors.Is(err, errNilConfig) {
 		t.Errorf("error '%v', expected '%v'", err, errNilConfig)
 	}

-	m, err := setupSyncManager(&Config{SyncTrades: true}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
+	_, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
+	if !errors.Is(err, currency.ErrCurrencyCodeEmpty) {
+		t.Errorf("error '%v', expected '%v'", err, currency.ErrCurrencyCodeEmpty)
+	}
+
+	_, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.BTC}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
+	if !errors.Is(err, currency.ErrFiatDisplayCurrencyIsNotFiat) {
+		t.Errorf("error '%v', expected '%v'", err, currency.ErrFiatDisplayCurrencyIsNotFiat)
+	}
+
+	_, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.USD}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
+	if !errors.Is(err, common.ErrNilPointer) {
+		t.Errorf("error '%v', expected '%v'", err, common.ErrNilPointer)
+	}
+
+	m, err := setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.PairFormat{}}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -40,7 +60,7 @@ func TestSetupSyncManager(t *testing.T) {

 func TestSyncManagerStart(t *testing.T) {
 	t.Parallel()
-	m, err := setupSyncManager(&Config{SyncTrades: true}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
+	m, err := setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.PairFormat{}}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -52,7 +72,7 @@ func TestSyncManagerStart(t *testing.T) {
 	exch.SetDefaults()
 	em.Add(exch)
 	m.exchangeManager = em
-	m.config.SyncContinuously = true
+	m.config.SynchronizeContinuously = true
 	err = m.Start()
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
@@ -85,7 +105,7 @@ func TestSyncManagerStop(t *testing.T) {
 	}
 	exch.SetDefaults()
 	em.Add(exch)
-	m, err = setupSyncManager(&Config{SyncTrades: true, SyncContinuously: true}, em, &config.RemoteControlConfig{}, false)
+	m, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.PairFormat{}}, em, &config.RemoteControlConfig{}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -115,7 +135,7 @@ func TestPrintCurrencyFormat(t *testing.T) {

 func TestPrintConvertCurrencyFormat(t *testing.T) {
 	t.Parallel()
-	c := printConvertCurrencyFormat(currency.BTC, 1337, currency.USD)
+	c := printConvertCurrencyFormat(1337, currency.BTC, currency.USD)
 	if c == "" {
 		t.Error("expected formatted currency")
 	}
@@ -133,7 +153,7 @@ func TestPrintTickerSummary(t *testing.T) {
 	}
 	exch.SetDefaults()
 	em.Add(exch)
-	m, err = setupSyncManager(&Config{SyncTrades: true, SyncContinuously: true}, em, &config.RemoteControlConfig{}, false)
+	m, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.PairFormat{}}, em, &config.RemoteControlConfig{}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -172,7 +192,7 @@ func TestPrintOrderbookSummary(t *testing.T) {
 	}
 	exch.SetDefaults()
 	em.Add(exch)
-	m, err = setupSyncManager(&Config{SyncTrades: true, SyncContinuously: true}, em, &config.RemoteControlConfig{}, false)
+	m, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.PairFormat{}}, em, &config.RemoteControlConfig{}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
--- a/engine/sync_manager_types.go
+++ b/engine/sync_manager_types.go
@@ -30,16 +30,18 @@ type currencyPairSyncAgent struct {
 	Trade     syncBase
 }

-// Config stores the currency pair config
-type Config struct {
-	SyncTicker           bool
-	SyncOrderbook        bool
-	SyncTrades           bool
-	SyncContinuously     bool
-	SyncTimeoutREST      time.Duration
-	SyncTimeoutWebsocket time.Duration
-	NumWorkers           int
-	Verbose              bool
+// SyncManagerConfig stores the currency pair synchronization manager config
+type SyncManagerConfig struct {
+	SynchronizeTicker       bool
+	SynchronizeOrderbook    bool
+	SynchronizeTrades       bool
+	SynchronizeContinuously bool
+	TimeoutREST             time.Duration
+	TimeoutWebsocket        time.Duration
+	NumWorkers              int
+	FiatDisplayCurrency     currency.Code
+	PairFormatDisplay       *currency.PairFormat
+	Verbose                 bool
 }

 // syncManager stores the exchange currency pair syncer object
@@ -60,6 +62,6 @@ type syncManager struct {
 	tickerBatchLastRequested map[string]time.Time

 	remoteConfig    *config.RemoteControlConfig
-	config          Config
+	config          SyncManagerConfig
 	exchangeManager iExchangeManager
 }
--- a/engine/websocketroutine_manager.go
+++ b/engine/websocketroutine_manager.go
@@ -5,7 +5,6 @@ import (
 	"sync/atomic"

 	"github.com/thrasher-corp/gocryptotrader/common"
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/account"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/fill"
@@ -18,7 +17,7 @@ import (
 )

 // setupWebsocketRoutineManager creates a new websocket routine manager
-func setupWebsocketRoutineManager(exchangeManager iExchangeManager, orderManager iOrderManager, syncer iCurrencyPairSyncer, cfg *config.CurrencyConfig, verbose bool) (*websocketRoutineManager, error) {
+func setupWebsocketRoutineManager(exchangeManager iExchangeManager, orderManager iOrderManager, syncer iCurrencyPairSyncer, cfg *currency.Config, verbose bool) (*websocketRoutineManager, error) {
 	if exchangeManager == nil {
 		return nil, errNilExchangeManager
 	}
--- a/engine/websocketroutine_manager_test.go
+++ b/engine/websocketroutine_manager_test.go
@@ -5,7 +5,6 @@ import (
 	"sync"
 	"testing"

-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/order"
@@ -34,12 +33,12 @@ func TestWebsocketRoutineManagerSetup(t *testing.T) {
 		t.Errorf("error '%v', expected '%v'", err, errNilCurrencyConfig)
 	}

-	_, err = setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &config.CurrencyConfig{}, true)
+	_, err = setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &currency.Config{}, true)
 	if !errors.Is(err, errNilCurrencyPairFormat) {
 		t.Errorf("error '%v', expected '%v'", err, errNilCurrencyPairFormat)
 	}

-	m, err := setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &config.CurrencyConfig{}, false)
+	m, err := setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &currency.Config{}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -54,7 +53,7 @@ func TestWebsocketRoutineManagerStart(t *testing.T) {
 	if !errors.Is(err, ErrNilSubsystem) {
 		t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
 	}
-	cfg := &config.CurrencyConfig{CurrencyPairFormat: &config.CurrencyPairFormatConfig{
+	cfg := &currency.Config{CurrencyPairFormat: &currency.PairFormat{
 		Uppercase: false,
 		Delimiter: "-",
 	}}
@@ -78,7 +77,7 @@ func TestWebsocketRoutineManagerIsRunning(t *testing.T) {
 		t.Error("expected false")
 	}

-	m, err := setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &config.CurrencyConfig{}, false)
+	m, err := setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &currency.Config{}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -102,7 +101,7 @@ func TestWebsocketRoutineManagerStop(t *testing.T) {
 		t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
 	}

-	m, err = setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &config.CurrencyConfig{}, false)
+	m, err = setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &currency.Config{}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -140,7 +139,7 @@ func TestWebsocketRoutineManagerHandleData(t *testing.T) {
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
-	cfg := &config.CurrencyConfig{CurrencyPairFormat: &config.CurrencyPairFormatConfig{
+	cfg := &currency.Config{CurrencyPairFormat: &currency.PairFormat{
 		Uppercase: false,
 		Delimiter: "-",
 	}}
--- a/engine/websocketroutine_manager_types.go
+++ b/engine/websocketroutine_manager_types.go
@@ -4,7 +4,7 @@ import (
 	"errors"
 	"sync"

-	"github.com/thrasher-corp/gocryptotrader/config"
+	"github.com/thrasher-corp/gocryptotrader/currency"
 )

 // websocketRoutineManager is used to process websocket updates from a unified location
@@ -14,7 +14,7 @@ type websocketRoutineManager struct {
 	exchangeManager iExchangeManager
 	orderManager    iOrderManager
 	syncer          iCurrencyPairSyncer
-	currencyConfig  *config.CurrencyConfig
+	currencyConfig  *currency.Config
 	shutdown        chan struct{}
 	wg              sync.WaitGroup
 }