exchange: upgrade UpdatePair method (#991)

* exchange: upgrade update pair

* exchanges: Add enabled string matching and format handling if discrepency is found.

* linter: fixes

* bithumb: fix tests

* BTSE: api change fix ordering

* huobi: fix tests

* gloriousnits: stage 1

* gloriousnits: stage 2

* currency: more nits

* bitmex: add spot and process pairs before currency package call.

* bitmex: finished correct orderbook matching and other implementations

* linter: fix issue

* currency: Fix linter

* currency: segregate and protect pair store, update tests

* currency/manager: clean code, rm log output

* currency: Add store method and make sure formatting stays nil if not stored.

* gct: check errors

* engine/websocketroutineman: fix tests

* bybit: fix duplication bug

* huobi: fix test

* btse: fix tests?

* ob/buffer: fix tests

* Update currency/manager.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* glorious: nits

* glorious: nits strikes again.

* exchange: add bypassConfigFormatUpgrades to stop formatting

* GLORIOUS LINTER

* Update exchanges/bithumb/bithumb_wrapper.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* glorious: nits

* exchange: fix pair upgrade issue when duplications are in both avail and enabled pairs

* linter: fix shadow dec

* config: fix test

* Update currency/pair_test.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

Co-authored-by: Ryan O'Hara-Reid <ryan.oharareid@thrasher.io>
Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

engine/engine.go

@@ -792,7 +792,10 @@ func (bot *Engine) LoadExchange(name string, wg *sync.WaitGroup) error {
 			if err != nil {
 				return err
 			}
-			exchCfg.CurrencyPairs.StorePairs(assets[x], pairs, true)
+			err = exchCfg.CurrencyPairs.StorePairs(assets[x], pairs, true)
+			if err != nil {
+				return err
+			}
 		}
 	}
 

engine/helpers_test.go

@@ -1065,7 +1065,7 @@ func createDepositEngine(opts *fakeDepositExchangeOpts) *Engine {
 					Enabled: true,
 					CurrencyPairs: &currency.PairsManager{
 						UseGlobalFormat: true,
-						ConfigFormat:    &currency.PairFormat{},
+						ConfigFormat:    &currency.EMPTYFORMAT,
 						Pairs: map[asset.Item]*currency.PairStore{
 							asset.Spot: &ps,
 						},

engine/rpcserver.go

@@ -76,6 +76,7 @@ var (
 	errShutdownNotAllowed      = errors.New("shutting down this bot instance is not allowed via gRPC, please enable by command line flag --grpcshutdown or config.json field grpcAllowBotShutdown")
 	errGRPCShutdownSignalIsNil = errors.New("cannot shutdown, gRPC shutdown channel is nil")
 	errInvalidStrategy         = errors.New("invalid strategy")
+	errSpecificPairNotEnabled  = errors.New("specified pair is not enabled")
 )
 
 // RPCServer struct
@@ -344,14 +345,21 @@ func (s *RPCServer) GetExchangeInfo(_ context.Context, r *gctrpc.GenericExchange
 	resp.SupportedAssets = make(map[string]*gctrpc.PairsSupported)
 	assets := exchCfg.CurrencyPairs.GetAssetTypes(false)
 	for i := range assets {
-		ps, err := exchCfg.CurrencyPairs.Get(assets[i])
+		var enabled currency.Pairs
+		enabled, err = exchCfg.CurrencyPairs.GetPairs(assets[i], true)
+		if err != nil {
+			return nil, err
+		}
+
+		var available currency.Pairs
+		available, err = exchCfg.CurrencyPairs.GetPairs(assets[i], false)
 		if err != nil {
 			return nil, err
 		}
 
 		resp.SupportedAssets[assets[i].String()] = &gctrpc.PairsSupported{
-			EnabledPairs:   ps.Enabled.Join(),
-			AvailablePairs: ps.Available.Join(),
+			EnabledPairs:   enabled.Join(),
+			AvailablePairs: available.Join(),
 		}
 	}
 	return resp, nil
@@ -1970,14 +1978,21 @@ func (s *RPCServer) GetExchangePairs(_ context.Context, r *gctrpc.GetExchangePai
 			continue
 		}
 
-		ps, err := exchCfg.CurrencyPairs.Get(assetTypes[x])
+		var enabled currency.Pairs
+		enabled, err = exchCfg.CurrencyPairs.GetPairs(assetTypes[x], true)
+		if err != nil {
+			return nil, err
+		}
+
+		var available currency.Pairs
+		available, err = exchCfg.CurrencyPairs.GetPairs(assetTypes[x], false)
 		if err != nil {
 			return nil, err
 		}
 
 		resp.SupportedAssets[assetTypes[x].String()] = &gctrpc.PairsSupported{
-			AvailablePairs: ps.Available.Join(),
-			EnabledPairs:   ps.Enabled.Join(),
+			AvailablePairs: available.Join(),
+			EnabledPairs:   enabled.Join(),
 		}
 	}
 	return &resp, nil
@@ -2024,31 +2039,36 @@ func (s *RPCServer) SetExchangePair(_ context.Context, r *gctrpc.SetExchangePair
 		}
 
 		if r.Enable {
-			err = exchCfg.CurrencyPairs.EnablePair(a,
-				p.Format(pairFmt.Delimiter, pairFmt.Uppercase))
+			err = exchCfg.CurrencyPairs.EnablePair(a, p.Format(pairFmt))
 			if err != nil {
-				newErrors = append(newErrors, err)
+				newErrors = append(newErrors, fmt.Errorf("%s %w", r.Pairs[i], err))
 				continue
 			}
 			err = base.CurrencyPairs.EnablePair(a, p)
 			if err != nil {
-				newErrors = append(newErrors, err)
+				newErrors = append(newErrors, fmt.Errorf("%s %w", r.Pairs[i], err))
 				continue
 			}
 			pass = true
 			continue
 		}
 
-		err = exchCfg.CurrencyPairs.DisablePair(a,
-			p.Format(pairFmt.Delimiter, pairFmt.Uppercase))
+		err = exchCfg.CurrencyPairs.DisablePair(a, p.Format(pairFmt))
 		if err != nil {
-			newErrors = append(newErrors, err)
-			continue
+			if errors.Is(err, currency.ErrPairNotFound) {
+				newErrors = append(newErrors, fmt.Errorf("%s %w", r.Pairs[i], errSpecificPairNotEnabled))
+				continue
+			}
+			return nil, err
 		}
+
 		err = base.CurrencyPairs.DisablePair(a, p)
 		if err != nil {
-			newErrors = append(newErrors, err)
-			continue
+			if errors.Is(err, currency.ErrPairNotFound) {
+				newErrors = append(newErrors, fmt.Errorf("%s %w", r.Pairs[i], errSpecificPairNotEnabled))
+				continue
+			}
+			return nil, err
 		}
 		pass = true
 	}
@@ -2913,13 +2933,25 @@ func (s *RPCServer) SetAllExchangePairs(_ context.Context, r *gctrpc.SetExchange
 			if err != nil {
 				return nil, err
 			}
-			exchCfg.CurrencyPairs.StorePairs(assets[i], pairs, true)
-			base.CurrencyPairs.StorePairs(assets[i], pairs, true)
+			err = exchCfg.CurrencyPairs.StorePairs(assets[i], pairs, true)
+			if err != nil {
+				return nil, err
+			}
+			err = base.CurrencyPairs.StorePairs(assets[i], pairs, true)
+			if err != nil {
+				return nil, err
+			}
 		}
 	} else {
 		for i := range assets {
-			exchCfg.CurrencyPairs.StorePairs(assets[i], nil, true)
-			base.CurrencyPairs.StorePairs(assets[i], nil, true)
+			err = exchCfg.CurrencyPairs.StorePairs(assets[i], nil, true)
+			if err != nil {
+				return nil, err
+			}
+			err = base.CurrencyPairs.StorePairs(assets[i], nil, true)
+			if err != nil {
+				return nil, err
+			}
 		}
 	}
 

engine/rpcserver_test.go

@@ -1464,6 +1464,7 @@ func TestCheckVars(t *testing.T) {
 		},
 		ConfigFormat: &currency.PairFormat{
 			Uppercase: true,
+			Delimiter: currency.DashDelimiter,
 		},
 	}
 	err = e.GetBase().StoreAssetPairFormat(asset.Spot, fmt1)
@@ -1492,7 +1493,10 @@ func TestCheckVars(t *testing.T) {
 		{Delimiter: currency.DashDelimiter, Base: currency.BTC, Quote: currency.USDT},
 	}
 
-	e.GetBase().CurrencyPairs.StorePairs(asset.Spot, data, false)
+	err = e.GetBase().CurrencyPairs.StorePairs(asset.Spot, data, false)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	err = checkParams("Binance", e, asset.Spot, currency.NewPair(currency.BTC, currency.USDT))
 	if !errors.Is(err, errCurrencyNotEnabled) {
@@ -2174,7 +2178,7 @@ func TestCurrencyStateTradingPair(t *testing.T) {
 	b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
 	b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
 		AssetEnabled: convert.BoolPtr(true),
-		ConfigFormat: &currency.PairFormat{},
+		ConfigFormat: &currency.EMPTYFORMAT,
 		Available:    currency.Pairs{cp},
 		Enabled:      currency.Pairs{cp},
 	}
@@ -2351,13 +2355,13 @@ func TestGetCollateral(t *testing.T) {
 	b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
 	b.CurrencyPairs.Pairs[asset.Futures] = &currency.PairStore{
 		AssetEnabled: convert.BoolPtr(true),
-		ConfigFormat: &currency.PairFormat{},
+		ConfigFormat: &currency.EMPTYFORMAT,
 		Available:    currency.Pairs{cp},
 		Enabled:      currency.Pairs{cp},
 	}
 	b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
 		AssetEnabled: convert.BoolPtr(true),
-		ConfigFormat: &currency.PairFormat{},
+		ConfigFormat: &currency.EMPTYFORMAT,
 		Available:    currency.Pairs{cp},
 		Enabled:      currency.Pairs{cp},
 	}

engine/sync_manager.go

@@ -87,8 +87,7 @@ func setupSyncManager(c *SyncManagerConfig, exchangeManager iExchangeManager, re
 		exchangeManager:                exchangeManager,
 		websocketRoutineManagerEnabled: websocketRoutineManagerEnabled,
 		fiatDisplayCurrency:            c.FiatDisplayCurrency,
-		delimiter:                      c.PairFormatDisplay.Delimiter,
-		uppercase:                      c.PairFormatDisplay.Uppercase,
+		format:                         *c.PairFormatDisplay,
 		tickerBatchLastRequested:       make(map[string]time.Time),
 	}
 
@@ -813,7 +812,7 @@ func (m *syncManager) FormatCurrency(p currency.Pair) currency.Pair {
 	if m == nil || atomic.LoadInt32(&m.started) == 0 {
 		return p
 	}
-	return p.Format(m.delimiter, m.uppercase)
+	return p.Format(m.format)
 }
 
 const (

engine/sync_manager_test.go

@@ -49,7 +49,7 @@ func TestSetupSyncManager(t *testing.T) {
 		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)
+	m, err := setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.EMPTYFORMAT}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -60,7 +60,7 @@ func TestSetupSyncManager(t *testing.T) {
 
 func TestSyncManagerStart(t *testing.T) {
 	t.Parallel()
-	m, err := setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.PairFormat{}}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
+	m, err := setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.EMPTYFORMAT}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -105,7 +105,7 @@ func TestSyncManagerStop(t *testing.T) {
 	}
 	exch.SetDefaults()
 	em.Add(exch)
-	m, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.PairFormat{}}, em, &config.RemoteControlConfig{}, false)
+	m, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.EMPTYFORMAT}, em, &config.RemoteControlConfig{}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -153,7 +153,7 @@ func TestPrintTickerSummary(t *testing.T) {
 	}
 	exch.SetDefaults()
 	em.Add(exch)
-	m, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.PairFormat{}}, em, &config.RemoteControlConfig{}, false)
+	m, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.EMPTYFORMAT}, em, &config.RemoteControlConfig{}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -192,7 +192,7 @@ func TestPrintOrderbookSummary(t *testing.T) {
 	}
 	exch.SetDefaults()
 	em.Add(exch)
-	m, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.PairFormat{}}, em, &config.RemoteControlConfig{}, false)
+	m, err = setupSyncManager(&SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.EMPTYFORMAT}, em, &config.RemoteControlConfig{}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}

engine/sync_manager_types.go

@@ -49,8 +49,7 @@ type syncManager struct {
 	initSyncCompleted              int32
 	initSyncStarted                int32
 	started                        int32
-	delimiter                      string
-	uppercase                      bool
+	format                         currency.PairFormat
 	initSyncStartTime              time.Time
 	fiatDisplayCurrency            currency.Code
 	websocketRoutineManagerEnabled bool

engine/websocketroutine_manager.go

@@ -30,7 +30,7 @@ func setupWebsocketRoutineManager(exchangeManager iExchangeManager, orderManager
 	if cfg == nil {
 		return nil, errNilCurrencyConfig
 	}
-	if cfg.CurrencyPairFormat == nil && verbose {
+	if cfg.CurrencyPairFormat == nil {
 		return nil, errNilCurrencyPairFormat
 	}
 	man := &websocketRoutineManager{
@@ -49,6 +49,15 @@ func (m *websocketRoutineManager) Start() error {
 	if m == nil {
 		return fmt.Errorf("websocket routine manager %w", ErrNilSubsystem)
 	}
+
+	if m.currencyConfig == nil {
+		return errNilCurrencyConfig
+	}
+
+	if m.currencyConfig.CurrencyPairFormat == nil {
+		return errNilCurrencyPairFormat
+	}
+
 	if !atomic.CompareAndSwapInt32(&m.started, 0, 1) {
 		return ErrSubSystemAlreadyStarted
 	}
@@ -288,8 +297,7 @@ func (m *websocketRoutineManager) FormatCurrency(p currency.Pair) currency.Pair
 	if m == nil || atomic.LoadInt32(&m.started) == 0 {
 		return p
 	}
-	return p.Format(m.currencyConfig.CurrencyPairFormat.Delimiter,
-		m.currencyConfig.CurrencyPairFormat.Uppercase)
+	return p.Format(*m.currencyConfig.CurrencyPairFormat)
 }
 
 // printOrderSummary this function will be deprecated when a order manager

engine/websocketroutine_manager_test.go

@@ -38,7 +38,7 @@ func TestWebsocketRoutineManagerSetup(t *testing.T) {
 		t.Errorf("error '%v', expected '%v'", err, errNilCurrencyPairFormat)
 	}
 
-	m, err := setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &currency.Config{}, false)
+	m, err := setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &currency.Config{CurrencyPairFormat: &currency.PairFormat{}}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -77,7 +77,7 @@ func TestWebsocketRoutineManagerIsRunning(t *testing.T) {
 		t.Error("expected false")
 	}
 
-	m, err := setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &currency.Config{}, false)
+	m, err := setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &currency.Config{CurrencyPairFormat: &currency.PairFormat{}}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -101,7 +101,7 @@ func TestWebsocketRoutineManagerStop(t *testing.T) {
 		t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
 	}
 
-	m, err = setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &currency.Config{}, false)
+	m, err = setupWebsocketRoutineManager(SetupExchangeManager(), &OrderManager{}, &syncManager{}, &currency.Config{CurrencyPairFormat: &currency.PairFormat{}}, false)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}