GCT: general updates across codebase (#699)

* orderbook: export orderbook nodes for external strategy inspection

* orderbook: Add in methods for locking and unlocking multiple books at the same time e.g. book1.LockWith(book2); defer book1.UnlockWith(book2)

* include waiting functionality for depth change alert

* backtester: add word.

* log: include logger changes to impl with downstream integration

* engine: reduce params for loading exchange

* assort: rm verbose in tests, change wording in ob, expose sync.waitgroup for ext. sync options

* ticker: reduce map look ups and contention when using RW mutex when there are over 80% writes adds find last function to get the latest rate

* engine/syncmanager: add in waitgroup for step over for external package calls

* cleaup

* engine: linter fix

* currency/fx: include all references to fiat currencies to default

* orderbook: Add in fields to Unsafe type for strategies to detect potential out of sync book operations

* syncmanager: changed config variable to display correct time

* ordermanager: Add time when none provided

* currency/manager: update getasset param to get enabled assets for minor optimizations

* ftx: use get all wallet balances for a better accounts breakdown

* orderbook: unlock in reverse order

* bithumb: fixes bug on market buy and sell orders

* bithumb: fix bug for nonce is also time window sensitive

* bithumb: get orders add required parameter

* bithumb: Add asset type to account struct

* currency: improve log output when checking currency and it fails

* bithumb: Add error return on incomplete pair

* ticker:unexport all service related methods

* ticker/currency: fixes

* orderbook: fix comment

* engine: revert variable name in LoadExchange method

* sync_manager: fix panic when enabling disabling manager

* engine: fix naming convention of exported function and comments

* engine: update comment

* orderbook: fix comment for unsafe type

engine/sync_manager.go

@@ -79,6 +79,7 @@ func setupSyncManager(c *Config, exchangeManager iExchangeManager, websocketData
 		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.inService.Add(1)
 	return s, nil
 }
 
@@ -98,12 +99,13 @@ func (m *syncManager) Start() error {
 	if !atomic.CompareAndSwapInt32(&m.started, 0, 1) {
 		return ErrSubSystemAlreadyStarted
 	}
+	m.initSyncWG.Add(1)
+	m.inService.Done()
 	log.Debugln(log.SyncMgr, "Exchange CurrencyPairSyncer started.")
 	exchanges := m.exchangeManager.GetExchanges()
 	for x := range exchanges {
 		exchangeName := exchanges[x].GetName()
 		supportsWebsocket := exchanges[x].SupportsWebsocket()
-		assetTypes := exchanges[x].GetAssetTypes()
 		supportsREST := exchanges[x].SupportsREST()
 
 		if !supportsREST && !supportsWebsocket {
@@ -150,6 +152,7 @@ func (m *syncManager) Start() error {
 			usingREST = true
 		}
 
+		assetTypes := exchanges[x].GetAssetTypes(false)
 		for y := range assetTypes {
 			if exchanges[x].GetBase().CurrencyPairs.IsAssetEnabled(assetTypes[y]) != nil {
 				log.Warnf(log.SyncMgr,
@@ -240,6 +243,7 @@ func (m *syncManager) Start() error {
 	for i := 0; i < m.config.NumWorkers; i++ {
 		go m.worker()
 	}
+	m.initSyncWG.Done()
 	return nil
 }
 
@@ -252,6 +256,7 @@ func (m *syncManager) Stop() error {
 	if !atomic.CompareAndSwapInt32(&m.started, 1, 0) {
 		return fmt.Errorf("exchange CurrencyPairSyncer %w", ErrSubSystemNotStarted)
 	}
+	m.inService.Add(1)
 	log.Debugln(log.SyncMgr, "Exchange CurrencyPairSyncer stopped.")
 	return nil
 }
@@ -482,7 +487,6 @@ func (m *syncManager) worker() {
 		exchanges := m.exchangeManager.GetExchanges()
 		for x := range exchanges {
 			exchangeName := exchanges[x].GetName()
-			assetTypes := exchanges[x].GetAssetTypes()
 			supportsREST := exchanges[x].SupportsREST()
 			supportsRESTTickerBatching := exchanges[x].SupportsRESTTickerBatchUpdates()
 			var usingREST bool
@@ -507,10 +511,8 @@ func (m *syncManager) worker() {
 				usingREST = true
 			}
 
+			assetTypes := exchanges[x].GetAssetTypes(true)
 			for y := range assetTypes {
-				if exchanges[x].GetBase().CurrencyPairs.IsAssetEnabled(assetTypes[y]) != nil {
-					continue
-				}
 				wsAssetSupported := exchanges[x].IsAssetWebsocketSupported(assetTypes[y])
 				enabledPairs, err := exchanges[x].GetEnabledPairs(assetTypes[y])
 				if err != nil {
@@ -582,7 +584,7 @@ func (m *syncManager) worker() {
 											c.Exchange,
 											m.FormatCurrency(c.Pair).String(),
 											strings.ToUpper(c.AssetType.String()),
-											m.config.SyncTimeoutREST,
+											m.config.SyncTimeoutWebsocket,
 										)
 										switchedToRest = true
 										m.setProcessing(c.Exchange, c.Pair, c.AssetType, SyncItemOrderbook, false)
@@ -879,6 +881,23 @@ func (m *syncManager) PrintOrderbookSummary(result *orderbook.Base, protocol str
 	)
 }
 
+// WaitForInitialSync allows for a routine to wait for an initial sync to be
+// completed without exposing the underlying type. This needs to be called in a
+// separate routine.
+func (m *syncManager) WaitForInitialSync() error {
+	if m == nil {
+		return fmt.Errorf("sync manager %w", ErrNilSubsystem)
+	}
+
+	m.inService.Wait()
+	if atomic.LoadInt32(&m.started) == 0 {
+		return fmt.Errorf("sync manager %w", ErrSubSystemNotStarted)
+	}
+
+	m.initSyncWG.Wait()
+	return nil
+}
+
 func relayWebsocketEvent(result interface{}, event, assetType, exchangeName string) {
 	evt := WebsocketEvent{
 		Data:      result,