diff --git a/backtester/engine/setup.go b/backtester/engine/setup.go
index a8a28527..edabb56f 100644
--- a/backtester/engine/setup.go
+++ b/backtester/engine/setup.go
@@ -158,7 +158,7 @@ func (bt *BackTest) SetupFromConfig(cfg *config.Config, templatePath, output str
 				if err != nil {
 					return err
 				}
-				err = exch.UpdateTradablePairs(context.TODO(), true)
+				err = exch.UpdateTradablePairs(context.TODO())
 				if err != nil {
 					return err
 				}
diff --git a/cmd/exchange_template/wrapper.tmpl b/cmd/exchange_template/wrapper.tmpl
index b47b6959..4d5ab654 100644
--- a/cmd/exchange_template/wrapper.tmpl
+++ b/cmd/exchange_template/wrapper.tmpl
@@ -186,16 +186,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 }
 
 // UpdateTradablePairs updates the exchanges available pairs and stores them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assetTypes := e.GetAssetTypes(false)
 	for x := range assetTypes {
 		pairs, err := e.FetchTradablePairs(ctx, assetTypes[x])
 		if err != nil {
 			return err
 		}
-
-		err = e.UpdatePairs(pairs, assetTypes[x], false, forceUpdate)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, assetTypes[x], false); err != nil {
 			return err
 		}
 	}
diff --git a/cmd/exchange_wrapper_issues/main.go b/cmd/exchange_wrapper_issues/main.go
index 0680dd2d..bb4cb5b4 100644
--- a/cmd/exchange_wrapper_issues/main.go
+++ b/cmd/exchange_wrapper_issues/main.go
@@ -412,7 +412,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, cfg *Config) []E
 				Response:   jsonifyInterface([]any{fetchTradablePairsResponse}),
 			})
 			// r6
-			err = e.UpdateTradablePairs(context.TODO(), false)
+			err = e.UpdateTradablePairs(context.TODO())
 			msg = ""
 			if err != nil {
 				msg = err.Error()
diff --git a/cmd/exchange_wrapper_standards/exchange_wrapper_standards_test.go b/cmd/exchange_wrapper_standards/exchange_wrapper_standards_test.go
index 69e7fcf7..ce5ae01e 100644
--- a/cmd/exchange_wrapper_standards/exchange_wrapper_standards_test.go
+++ b/cmd/exchange_wrapper_standards/exchange_wrapper_standards_test.go
@@ -96,7 +96,8 @@ func setupExchange(ctx context.Context, t *testing.T, name string, cfg *config.C
 	if err != nil {
 		t.Fatalf("Cannot setup %v exchange Setup %v", name, err)
 	}
-	err = exch.UpdateTradablePairs(ctx, true)
+
+	err = exch.UpdateTradablePairs(ctx)
 	require.Truef(t, errors.Is(err, context.DeadlineExceeded) || err == nil, "Exchange %s UpdateTradablePairs must not error: %s", name, err)
 	b := exch.GetBase()
 	assets := b.CurrencyPairs.GetAssetTypes(false)
diff --git a/engine/rpcserver.go b/engine/rpcserver.go
index cb9a479d..585f2703 100644
--- a/engine/rpcserver.go
+++ b/engine/rpcserver.go
@@ -2925,8 +2925,7 @@ func (s *RPCServer) UpdateExchangeSupportedPairs(ctx context.Context, r *gctrpc.
 			errors.New("cannot auto pair update for exchange, a manual update is needed")
 	}
 
-	err = exch.UpdateTradablePairs(ctx, false)
-	if err != nil {
+	if err := exch.UpdateTradablePairs(ctx); err != nil {
 		return nil, err
 	}
 
diff --git a/exchanges/binance/binance_live_test.go b/exchanges/binance/binance_live_test.go
index 9b455e78..170b7d02 100644
--- a/exchanges/binance/binance_live_test.go
+++ b/exchanges/binance/binance_live_test.go
@@ -42,7 +42,7 @@ func TestMain(m *testing.M) {
 	}
 	e.Websocket.DataHandler = sharedtestvalues.GetWebsocketInterfaceChannelOverride()
 	log.Printf(sharedtestvalues.LiveTesting, e.Name)
-	if err := e.UpdateTradablePairs(context.Background(), true); err != nil {
+	if err := e.UpdateTradablePairs(context.Background()); err != nil {
 		log.Fatalf("Binance UpdateTradablePairs error: %s", err)
 	}
 	os.Exit(m.Run())
diff --git a/exchanges/binance/binance_mock_test.go b/exchanges/binance/binance_mock_test.go
index 46d404fc..51d85a31 100644
--- a/exchanges/binance/binance_mock_test.go
+++ b/exchanges/binance/binance_mock_test.go
@@ -28,7 +28,7 @@ func TestMain(m *testing.M) {
 	if err := testexch.MockHTTPInstance(e); err != nil {
 		log.Fatalf("Binance MockHTTPInstance error: %s", err)
 	}
-	if err := e.UpdateTradablePairs(context.Background(), true); err != nil {
+	if err := e.UpdateTradablePairs(context.Background()); err != nil {
 		log.Fatalf("Binance UpdateTradablePairs error: %s", err)
 	}
 	os.Exit(m.Run())
diff --git a/exchanges/binance/binance_wrapper.go b/exchanges/binance/binance_wrapper.go
index d5863e1b..e3164b35 100644
--- a/exchanges/binance/binance_wrapper.go
+++ b/exchanges/binance/binance_wrapper.go
@@ -318,16 +318,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assetTypes := e.GetAssetTypes(false)
 	for i := range assetTypes {
 		pairs, err := e.FetchTradablePairs(ctx, assetTypes[i])
 		if err != nil {
 			return err
 		}
-
-		err = e.UpdatePairs(pairs, assetTypes[i], false, forceUpdate)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, assetTypes[i], false); err != nil {
 			return err
 		}
 	}
diff --git a/exchanges/binanceus/binanceus_test.go b/exchanges/binanceus/binanceus_test.go
index a2b1b169..89baa09c 100644
--- a/exchanges/binanceus/binanceus_test.go
+++ b/exchanges/binanceus/binanceus_test.go
@@ -114,7 +114,7 @@ func TestFetchTradablePairs(t *testing.T) {
 
 func TestUpdateTradablePairs(t *testing.T) {
 	t.Parallel()
-	err := e.UpdateTradablePairs(t.Context(), false)
+	err := e.UpdateTradablePairs(t.Context())
 	if err != nil {
 		t.Error("Binanceus UpdateTradablePairs() error", err)
 	}
diff --git a/exchanges/binanceus/binanceus_wrapper.go b/exchanges/binanceus/binanceus_wrapper.go
index 3b387ae9..7dab368e 100644
--- a/exchanges/binanceus/binanceus_wrapper.go
+++ b/exchanges/binanceus/binanceus_wrapper.go
@@ -221,13 +221,12 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	pairs, err := e.FetchTradablePairs(ctx, asset.Spot)
 	if err != nil {
 		return err
 	}
-	err = e.UpdatePairs(pairs, asset.Spot, false, forceUpdate)
-	if err != nil {
+	if err := e.UpdatePairs(pairs, asset.Spot, false); err != nil {
 		return err
 	}
 	return e.EnsureOnePairEnabled()
diff --git a/exchanges/bitfinex/bitfinex_wrapper.go b/exchanges/bitfinex/bitfinex_wrapper.go
index 31ba0f3a..af8748e6 100644
--- a/exchanges/bitfinex/bitfinex_wrapper.go
+++ b/exchanges/bitfinex/bitfinex_wrapper.go
@@ -253,16 +253,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assets := e.CurrencyPairs.GetAssetTypes(false)
 	for i := range assets {
 		pairs, err := e.FetchTradablePairs(ctx, assets[i])
 		if err != nil {
 			return err
 		}
-
-		err = e.UpdatePairs(pairs, assets[i], false, forceUpdate)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, assets[i], false); err != nil {
 			return err
 		}
 	}
diff --git a/exchanges/bitflyer/bitflyer_wrapper.go b/exchanges/bitflyer/bitflyer_wrapper.go
index a5b0c75a..697ff0d9 100644
--- a/exchanges/bitflyer/bitflyer_wrapper.go
+++ b/exchanges/bitflyer/bitflyer_wrapper.go
@@ -130,15 +130,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assets := e.CurrencyPairs.GetAssetTypes(false)
 	for _, a := range assets {
 		pairs, err := e.FetchTradablePairs(ctx, a)
 		if err != nil {
 			return err
 		}
-		err = e.UpdatePairs(pairs, a, false, forceUpdate)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, a, false); err != nil {
 			return err
 		}
 	}
diff --git a/exchanges/bithumb/bithumb_wrapper.go b/exchanges/bithumb/bithumb_wrapper.go
index d88428eb..1822fbe5 100644
--- a/exchanges/bithumb/bithumb_wrapper.go
+++ b/exchanges/bithumb/bithumb_wrapper.go
@@ -197,13 +197,12 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, _ asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	pairs, err := e.FetchTradablePairs(ctx, asset.Spot)
 	if err != nil {
 		return err
 	}
-	err = e.UpdatePairs(pairs, asset.Spot, false, forceUpdate)
-	if err != nil {
+	if err := e.UpdatePairs(pairs, asset.Spot, false); err != nil {
 		return err
 	}
 	return e.EnsureOnePairEnabled()
diff --git a/exchanges/bitmex/bitmex_test.go b/exchanges/bitmex/bitmex_test.go
index 74059a89..1aab2b25 100644
--- a/exchanges/bitmex/bitmex_test.go
+++ b/exchanges/bitmex/bitmex_test.go
@@ -747,7 +747,7 @@ func TestWsAuth(t *testing.T) {
 
 func TestUpdateTradablePairs(t *testing.T) {
 	t.Parallel()
-	err := e.UpdateTradablePairs(t.Context(), true)
+	err := e.UpdateTradablePairs(t.Context())
 	require.NoError(t, err)
 }
 
@@ -942,7 +942,7 @@ func TestWsTrades(t *testing.T) {
 
 func TestGetRecentTrades(t *testing.T) {
 	t.Parallel()
-	err := e.UpdateTradablePairs(t.Context(), false)
+	err := e.UpdateTradablePairs(t.Context())
 	require.NoError(t, err)
 	currencyPair := e.CurrencyPairs.Pairs[asset.Futures].Available[0]
 	_, err = e.GetRecentTrades(t.Context(), currencyPair, asset.Futures)
@@ -951,7 +951,7 @@ func TestGetRecentTrades(t *testing.T) {
 
 func TestGetHistoricTrades(t *testing.T) {
 	t.Parallel()
-	err := e.UpdateTradablePairs(t.Context(), false)
+	err := e.UpdateTradablePairs(t.Context())
 	require.NoError(t, err)
 	currencyPair := e.CurrencyPairs.Pairs[asset.Futures].Available[0]
 	_, err = e.GetHistoricTrades(t.Context(), currencyPair, asset.Futures, time.Now().Add(-time.Minute), time.Now())
diff --git a/exchanges/bitmex/bitmex_wrapper.go b/exchanges/bitmex/bitmex_wrapper.go
index 01eae97a..5eff6c6a 100644
--- a/exchanges/bitmex/bitmex_wrapper.go
+++ b/exchanges/bitmex/bitmex_wrapper.go
@@ -275,16 +275,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, _ bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assets := e.GetAssetTypes(false)
 	for x := range assets {
 		pairs, err := e.FetchTradablePairs(ctx, assets[x])
 		if err != nil {
 			return err
 		}
-
-		err = e.UpdatePairs(pairs, assets[x], false, false)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, assets[x], false); err != nil {
 			return err
 		}
 	}
diff --git a/exchanges/bitstamp/bitstamp_test.go b/exchanges/bitstamp/bitstamp_test.go
index 81ca525d..9669d854 100644
--- a/exchanges/bitstamp/bitstamp_test.go
+++ b/exchanges/bitstamp/bitstamp_test.go
@@ -235,7 +235,7 @@ func TestFetchTradablePairs(t *testing.T) {
 
 func TestUpdateTradablePairs(t *testing.T) {
 	t.Parallel()
-	err := e.UpdateTradablePairs(t.Context(), true)
+	err := e.UpdateTradablePairs(t.Context())
 	require.NoError(t, err, "UpdateTradablePairs must not error")
 }
 
diff --git a/exchanges/bitstamp/bitstamp_wrapper.go b/exchanges/bitstamp/bitstamp_wrapper.go
index 78c78a5a..bfa4552d 100644
--- a/exchanges/bitstamp/bitstamp_wrapper.go
+++ b/exchanges/bitstamp/bitstamp_wrapper.go
@@ -196,13 +196,12 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, _ asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	pairs, err := e.FetchTradablePairs(ctx, asset.Spot)
 	if err != nil {
 		return err
 	}
-	err = e.UpdatePairs(pairs, asset.Spot, false, forceUpdate)
-	if err != nil {
+	if err := e.UpdatePairs(pairs, asset.Spot, false); err != nil {
 		return err
 	}
 	return e.EnsureOnePairEnabled()
diff --git a/exchanges/blackbox_test.go b/exchanges/blackbox_test.go
index 56451e54..3b72ce0d 100644
--- a/exchanges/blackbox_test.go
+++ b/exchanges/blackbox_test.go
@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
 	shared "github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
 )
@@ -14,7 +15,7 @@ type mockEx struct {
 	flow chan int
 }
 
-func (m *mockEx) UpdateTradablePairs(_ context.Context, _ bool) error {
+func (m *mockEx) UpdateTradablePairs(context.Context) error {
 	m.flow <- 42
 	return nil
 }
@@ -26,6 +27,7 @@ func TestBootstrap(t *testing.T) {
 	}
 	m.Features.Enabled.AutoPairUpdates = true
 	err := exchange.Bootstrap(t.Context(), m)
-	assert.NoError(t, err, "Bootstrap should not error")
+	require.NoError(t, err, "Bootstrap must not error")
+	require.Len(t, m.flow, 1)
 	assert.Equal(t, 42, <-m.flow, "UpdateTradablePairs should be called on the exchange")
 }
diff --git a/exchanges/btcmarkets/btcmarkets_wrapper.go b/exchanges/btcmarkets/btcmarkets_wrapper.go
index 394cfc32..b8fddb8b 100644
--- a/exchanges/btcmarkets/btcmarkets_wrapper.go
+++ b/exchanges/btcmarkets/btcmarkets_wrapper.go
@@ -194,13 +194,12 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	pairs, err := e.FetchTradablePairs(ctx, asset.Spot)
 	if err != nil {
 		return err
 	}
-	err = e.UpdatePairs(pairs, asset.Spot, false, forceUpdate)
-	if err != nil {
+	if err := e.UpdatePairs(pairs, asset.Spot, false); err != nil {
 		return err
 	}
 	return e.EnsureOnePairEnabled()
diff --git a/exchanges/btse/btse_wrapper.go b/exchanges/btse/btse_wrapper.go
index 68f69ab2..6d2a9f4c 100644
--- a/exchanges/btse/btse_wrapper.go
+++ b/exchanges/btse/btse_wrapper.go
@@ -211,15 +211,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	a := e.GetAssetTypes(false)
 	for i := range a {
 		pairs, err := e.FetchTradablePairs(ctx, a[i])
 		if err != nil {
 			return err
 		}
-		err = e.UpdatePairs(pairs, a[i], false, forceUpdate)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, a[i], false); err != nil {
 			return err
 		}
 	}
diff --git a/exchanges/bybit/bybit_live_test.go b/exchanges/bybit/bybit_live_test.go
index cf82f2d1..5df09497 100644
--- a/exchanges/bybit/bybit_live_test.go
+++ b/exchanges/bybit/bybit_live_test.go
@@ -48,7 +48,7 @@ func instantiateTradablePairs() {
 		}
 	}
 
-	err := e.UpdateTradablePairs(context.Background(), true)
+	err := e.UpdateTradablePairs(context.Background())
 	handleError("unable to UpdateTradablePairs", err)
 
 	setTradablePair := func(assetType asset.Item, p *currency.Pair) {
diff --git a/exchanges/bybit/bybit_mock_test.go b/exchanges/bybit/bybit_mock_test.go
index 1e9dae6d..f1098584 100644
--- a/exchanges/bybit/bybit_mock_test.go
+++ b/exchanges/bybit/bybit_mock_test.go
@@ -29,7 +29,7 @@ func TestMain(m *testing.M) {
 		log.Fatalf("Bybit MockHTTPInstance error: %s", err)
 	}
 
-	if err := e.UpdateTradablePairs(context.Background(), true); err != nil {
+	if err := e.UpdateTradablePairs(context.Background()); err != nil {
 		log.Fatalf("Bybit unable to UpdateTradablePairs: %s", err)
 	}
 
diff --git a/exchanges/bybit/bybit_wrapper.go b/exchanges/bybit/bybit_wrapper.go
index e31272c6..49ca4b87 100644
--- a/exchanges/bybit/bybit_wrapper.go
+++ b/exchanges/bybit/bybit_wrapper.go
@@ -500,15 +500,14 @@ func getCategoryName(a asset.Item) string {
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assetTypes := e.GetAssetTypes(true)
 	for i := range assetTypes {
 		pairs, err := e.FetchTradablePairs(ctx, assetTypes[i])
 		if err != nil {
 			return err
 		}
-		err = e.UpdatePairs(pairs, assetTypes[i], false, forceUpdate)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, assetTypes[i], false); err != nil {
 			return err
 		}
 	}
diff --git a/exchanges/coinbase/coinbase_wrapper.go b/exchanges/coinbase/coinbase_wrapper.go
index d3e24d29..e7a5efe5 100644
--- a/exchanges/coinbase/coinbase_wrapper.go
+++ b/exchanges/coinbase/coinbase_wrapper.go
@@ -197,14 +197,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 }
 
 // UpdateTradablePairs updates the exchanges available pairs and stores them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assets := e.GetAssetTypes(false)
 	for i := range assets {
 		pairs, err := e.FetchTradablePairs(ctx, assets[i])
 		if err != nil {
 			return err
 		}
-		if err := e.UpdatePairs(pairs, assets[i], false, forceUpdate); err != nil {
+		if err := e.UpdatePairs(pairs, assets[i], false); err != nil {
 			return err
 		}
 	}
diff --git a/exchanges/coinut/coinut_wrapper.go b/exchanges/coinut/coinut_wrapper.go
index 1af99202..788c3dbc 100644
--- a/exchanges/coinut/coinut_wrapper.go
+++ b/exchanges/coinut/coinut_wrapper.go
@@ -186,13 +186,12 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, _ asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	pairs, err := e.FetchTradablePairs(ctx, asset.Spot)
 	if err != nil {
 		return err
 	}
-	err = e.UpdatePairs(pairs, asset.Spot, false, forceUpdate)
-	if err != nil {
+	if err := e.UpdatePairs(pairs, asset.Spot, false); err != nil {
 		return err
 	}
 	return e.EnsureOnePairEnabled()
diff --git a/exchanges/deribit/deribit_test.go b/exchanges/deribit/deribit_test.go
index 49d81bf4..5e8095da 100644
--- a/exchanges/deribit/deribit_test.go
+++ b/exchanges/deribit/deribit_test.go
@@ -90,7 +90,7 @@ func TestMain(m *testing.M) {
 }
 
 func instantiateTradablePairs() {
-	if err := e.UpdateTradablePairs(context.Background(), true); err != nil {
+	if err := e.UpdateTradablePairs(context.Background()); err != nil {
 		log.Fatalf("Failed to update tradable pairs. Error: %v", err)
 	}
 
diff --git a/exchanges/deribit/deribit_wrapper.go b/exchanges/deribit/deribit_wrapper.go
index a0890a78..f5366837 100644
--- a/exchanges/deribit/deribit_wrapper.go
+++ b/exchanges/deribit/deribit_wrapper.go
@@ -223,7 +223,7 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, assetType asset.Item)
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assets := e.GetAssetTypes(false)
 	errs := common.CollectErrors(len(assets))
 	for x := range assets {
@@ -234,7 +234,7 @@ func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) er
 				errs.C <- err
 				return
 			}
-			errs.C <- e.UpdatePairs(pairs, assets[x], false, forceUpdate)
+			errs.C <- e.UpdatePairs(pairs, assets[x], false)
 		}(x)
 	}
 	return errs.Collect()
diff --git a/exchanges/exchange.go b/exchanges/exchange.go
index 7e79dd18..f30114e8 100644
--- a/exchanges/exchange.go
+++ b/exchanges/exchange.go
@@ -644,9 +644,13 @@ func (b *Base) EnsureOnePairEnabled() error {
 	return nil
 }
 
-// UpdatePairs updates the exchange currency pairs for either enabledPairs or
-// availablePairs
-func (b *Base) UpdatePairs(incoming currency.Pairs, a asset.Item, enabled, force bool) error {
+// UpdatePairs updates the exchange currency pairs for either enabledPairs or availablePairs
+func (b *Base) UpdatePairs(incoming currency.Pairs, a asset.Item, enabled bool) error {
+	if len(incoming) == 0 && !enabled {
+		// Exchange reports a successful response (HTTP 200) but provides no currency pairs, so we preserve the existing
+		// available pairs.
+		return fmt.Errorf("%w: updating available pairs", currency.ErrCurrencyPairsEmpty)
+	}
 	pFmt, err := b.GetPairFormat(a, false)
 	if err != nil {
 		return err
@@ -667,50 +671,27 @@ func (b *Base) UpdatePairs(incoming currency.Pairs, a asset.Item, enabled, force
 		return err
 	}
 
-	if force || len(diff.New) != 0 || len(diff.Remove) != 0 || diff.FormatDifference {
-		var updateType string
-		if enabled {
-			updateType = "enabled"
-		} else {
-			updateType = "available"
-		}
+	updateType := "enabled"
+	if !enabled {
+		updateType = "available"
+	}
 
-		if force {
-			log.Debugf(log.ExchangeSys,
-				"%s forced update of %s [%v] pairs.",
-				b.Name,
-				updateType,
-				strings.ToUpper(a.String()))
-		} else {
-			if len(diff.New) > 0 {
-				log.Debugf(log.ExchangeSys,
-					"%s Updating %s pairs [%v] - Added: %s.\n",
-					b.Name,
-					updateType,
-					strings.ToUpper(a.String()),
-					diff.New)
-			}
-			if len(diff.Remove) > 0 {
-				log.Debugf(log.ExchangeSys,
-					"%s Updating %s pairs [%v] - Removed: %s.\n",
-					b.Name,
-					updateType,
-					strings.ToUpper(a.String()),
-					diff.Remove)
-			}
-		}
-		err = common.NilGuard(b.Config, b.Config.CurrencyPairs)
-		if err != nil {
-			return err
-		}
-		err = b.Config.CurrencyPairs.StorePairs(a, incoming, enabled)
-		if err != nil {
-			return err
-		}
-		err = b.CurrencyPairs.StorePairs(a, incoming, enabled)
-		if err != nil {
-			return err
-		}
+	if len(diff.New) > 0 {
+		log.Debugf(log.ExchangeSys, "%s Updating %s pairs [%v] - Added: %s.\n", b.Name, updateType, strings.ToUpper(a.String()), diff.New)
+	}
+	if len(diff.Remove) > 0 {
+		log.Debugf(log.ExchangeSys, "%s Updating %s pairs [%v] - Removed: %s.\n", b.Name, updateType, strings.ToUpper(a.String()), diff.Remove)
+	}
+
+	if err := common.NilGuard(b.Config, b.Config.CurrencyPairs); err != nil {
+		return err
+	}
+
+	if err := b.Config.CurrencyPairs.StorePairs(a, incoming, enabled); err != nil {
+		return err
+	}
+	if err := b.CurrencyPairs.StorePairs(a, incoming, enabled); err != nil {
+		return err
 	}
 
 	if enabled {
@@ -776,21 +757,14 @@ func (b *Base) UpdatePairs(incoming currency.Pairs, a asset.Item, enabled, force
 		if err != nil {
 			return err
 		}
-		log.Debugf(log.ExchangeSys, "%s Enabled pairs missing for %s. Added %s.\n",
-			b.Name,
-			strings.ToUpper(a.String()),
-			randomPair)
+		log.Debugf(log.ExchangeSys, "%s Enabled pairs missing for %s. Added %s.\n", b.Name, strings.ToUpper(a.String()), randomPair)
 		enabledPairs = currency.Pairs{randomPair}
 	}
 
 	if len(diff.Remove) > 0 {
-		log.Debugf(log.ExchangeSys, "%s Checked and updated enabled pairs [%v] - Removed: %s.\n",
-			b.Name,
-			strings.ToUpper(a.String()),
-			diff.Remove)
+		log.Debugf(log.ExchangeSys, "%s Checked and updated enabled pairs [%v] - Removed: %s.\n", b.Name, strings.ToUpper(a.String()), diff.Remove)
 	}
-	err = b.Config.CurrencyPairs.StorePairs(a, enabledPairs, true)
-	if err != nil {
+	if err := b.Config.CurrencyPairs.StorePairs(a, enabledPairs, true); err != nil {
 		return err
 	}
 	return b.CurrencyPairs.StorePairs(a, enabledPairs, true)
@@ -1838,7 +1812,7 @@ func Bootstrap(ctx context.Context, b IBotExchange) error {
 	}
 
 	if b.GetEnabledFeatures().AutoPairUpdates {
-		if err := b.UpdateTradablePairs(ctx, false); err != nil {
+		if err := b.UpdateTradablePairs(ctx); err != nil {
 			return fmt.Errorf("failed to update tradable pairs: %w", err)
 		}
 	}
@@ -1897,13 +1871,12 @@ func GetDefaultConfig(ctx context.Context, exch IBotExchange) (*config.Exchange,
 		return nil, err
 	}
 
-	err = b.SetupDefaults(exchCfg)
-	if err != nil {
+	if err := b.SetupDefaults(exchCfg); err != nil {
 		return nil, err
 	}
 
 	if b.Features.Supports.RESTCapabilities.AutoPairUpdates {
-		err = exch.UpdateTradablePairs(ctx, true)
+		err = exch.UpdateTradablePairs(ctx)
 		if err != nil {
 			return nil, err
 		}
diff --git a/exchanges/exchange_test.go b/exchanges/exchange_test.go
index f57c97bd..03293fd9 100644
--- a/exchanges/exchange_test.go
+++ b/exchanges/exchange_test.go
@@ -940,18 +940,18 @@ func TestUpdatePairs(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, true, false)
+	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, true)
 	if err != nil {
 		t.Errorf("TestUpdatePairs error: %s", err)
 	}
 
-	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, false, false)
+	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, false)
 	if err != nil {
 		t.Errorf("TestUpdatePairs error: %s", err)
 	}
 
 	// Test updating the same new products, diff should be 0
-	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, true, false)
+	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, true)
 	if err != nil {
 		t.Errorf("TestUpdatePairs error: %s", err)
 	}
@@ -962,7 +962,7 @@ func TestUpdatePairs(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, true, true)
+	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, true)
 	if err != nil {
 		t.Errorf("TestUpdatePairs error: %s", err)
 	}
@@ -978,13 +978,13 @@ func TestUpdatePairs(t *testing.T) {
 		t.Fatal(err)
 	}
 	UAC.Name = defaultTestExchange
-	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, false, false)
+	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, false)
 	if err != nil {
 		t.Errorf("Exchange UpdatePairs() error: %s", err)
 	}
 
 	// Test updating the same new products, diff should be 0
-	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, false, false)
+	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, false)
 	if err != nil {
 		t.Errorf("Exchange UpdatePairs() error: %s", err)
 	}
@@ -994,7 +994,7 @@ func TestUpdatePairs(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, false, true)
+	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, false)
 	if err != nil {
 		t.Errorf("Forced Exchange UpdatePairs() error: %s", err)
 	}
@@ -1004,21 +1004,21 @@ func TestUpdatePairs(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, false, false)
+	err = UAC.UpdatePairs(exchangeProducts, asset.Spot, false)
 	if err != nil {
 		t.Errorf("Exchange UpdatePairs() error: %s", err)
 	}
 
-	err = UAC.UpdatePairs(currency.Pairs{currency.EMPTYPAIR, btcusdPair}, asset.Spot, true, true)
+	err = UAC.UpdatePairs(currency.Pairs{currency.EMPTYPAIR, btcusdPair}, asset.Spot, true)
 	assert.ErrorIs(t, err, currency.ErrCurrencyPairEmpty, "UpdatePairs should error on empty pairs")
 
-	err = UAC.UpdatePairs(currency.Pairs{btcusdPair, btcusdPair}, asset.Spot, false, true)
+	err = UAC.UpdatePairs(currency.Pairs{btcusdPair, btcusdPair}, asset.Spot, false)
 	assert.ErrorIs(t, err, currency.ErrPairDuplication, "UpdatePairs should error on Duplicates")
 
-	err = UAC.UpdatePairs(currency.Pairs{btcusdPair}, asset.Spot, false, true)
+	err = UAC.UpdatePairs(currency.Pairs{btcusdPair}, asset.Spot, false)
 	assert.NoError(t, err, "UpdatePairs should not error")
 
-	err = UAC.UpdatePairs(currency.Pairs{btcusdPair}, asset.Spot, true, true)
+	err = UAC.UpdatePairs(currency.Pairs{btcusdPair}, asset.Spot, true)
 	assert.NoError(t, err, "UpdatePairs should not error")
 
 	UAC.CurrencyPairs.UseGlobalFormat = true
@@ -1034,7 +1034,7 @@ func TestUpdatePairs(t *testing.T) {
 		currency.NewPair(currency.LTC, currency.USD),
 		currency.NewPair(currency.LTC, currency.USDT),
 	}
-	err = UAC.UpdatePairs(pairs, asset.Spot, true, true)
+	err = UAC.UpdatePairs(pairs, asset.Spot, true)
 	require.NoError(t, err)
 
 	pairs = currency.Pairs{
@@ -1043,7 +1043,7 @@ func TestUpdatePairs(t *testing.T) {
 		currency.NewPair(currency.LARIX, currency.USD),
 		currency.NewPair(currency.LTC, currency.USDT),
 	}
-	err = UAC.UpdatePairs(pairs, asset.Spot, false, true)
+	err = UAC.UpdatePairs(pairs, asset.Spot, false)
 	require.NoError(t, err)
 
 	uacEnabledPairs, err := UAC.GetEnabledPairs(asset.Spot)
@@ -1075,7 +1075,7 @@ func TestUpdatePairs(t *testing.T) {
 		unintentionalInput,
 	}
 
-	err = UAC.UpdatePairs(pairs, asset.Spot, true, true)
+	err = UAC.UpdatePairs(pairs, asset.Spot, true)
 	require.NoError(t, err)
 
 	pairs = currency.Pairs{
@@ -1086,7 +1086,7 @@ func TestUpdatePairs(t *testing.T) {
 		currency.NewPair(currency.LINK, currency.USD),
 	}
 
-	err = UAC.UpdatePairs(pairs, asset.Spot, false, true)
+	err = UAC.UpdatePairs(pairs, asset.Spot, false)
 	require.NoError(t, err)
 
 	uacEnabledPairs, err = UAC.GetEnabledPairs(asset.Spot)
@@ -1097,6 +1097,20 @@ func TestUpdatePairs(t *testing.T) {
 	if !uacEnabledPairs.Contains(currency.NewPair(currency.LINK, currency.USD), true) {
 		t.Fatalf("received: '%v' but expected: '%v'", false, true)
 	}
+
+	err = UAC.UpdatePairs(currency.Pairs{}, asset.Spot, true)
+	require.NoError(t, err, "purging all pairs must not error")
+
+	pairs, err = UAC.GetEnabledPairs(asset.Spot)
+	require.NoError(t, err)
+	require.Empty(t, pairs)
+
+	err = UAC.UpdatePairs(currency.Pairs{}, asset.Spot, false)
+	require.ErrorIs(t, err, currency.ErrCurrencyPairsEmpty, "Purging all available pairs must error")
+
+	avail, err := UAC.GetAvailablePairs(asset.Spot)
+	require.NoError(t, err)
+	assert.NotEmpty(t, avail, "Failed attempt to purge available pairs should not affect store")
 }
 
 func TestSupportsWebsocket(t *testing.T) {
@@ -2663,7 +2677,7 @@ func (f *FakeBase) SetDefaults() {
 	f.Requester, _ = request.New("test", common.NewHTTPClientWithTimeout(time.Second))
 	f.Features.Supports.RESTCapabilities.AutoPairUpdates = true
 }
-func (f *FakeBase) UpdateTradablePairs(context.Context, bool) error { return nil }
+func (f *FakeBase) UpdateTradablePairs(context.Context) error { return nil }
 
 func (f *FakeBase) Setup(*config.Exchange) error {
 	return nil
diff --git a/exchanges/exmo/exmo_wrapper.go b/exchanges/exmo/exmo_wrapper.go
index 3d758610..0fcea069 100644
--- a/exchanges/exmo/exmo_wrapper.go
+++ b/exchanges/exmo/exmo_wrapper.go
@@ -140,13 +140,12 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	pairs, err := e.FetchTradablePairs(ctx, asset.Spot)
 	if err != nil {
 		return err
 	}
-	err = e.UpdatePairs(pairs, asset.Spot, false, forceUpdate)
-	if err != nil {
+	if err := e.UpdatePairs(pairs, asset.Spot, false); err != nil {
 		return err
 	}
 	return e.EnsureOnePairEnabled()
diff --git a/exchanges/gateio/gateio_wrapper.go b/exchanges/gateio/gateio_wrapper.go
index e6cc4b72..27f2303e 100644
--- a/exchanges/gateio/gateio_wrapper.go
+++ b/exchanges/gateio/gateio_wrapper.go
@@ -516,18 +516,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assets := e.GetAssetTypes(false)
 	for x := range assets {
 		pairs, err := e.FetchTradablePairs(ctx, assets[x])
 		if err != nil {
 			return err
 		}
-		if len(pairs) == 0 {
-			return errors.New("no tradable pairs found")
-		}
-		err = e.UpdatePairs(pairs, assets[x], false, forceUpdate)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, assets[x], false); err != nil {
 			return err
 		}
 	}
diff --git a/exchanges/gateio/ws_ob_update_manager_test.go b/exchanges/gateio/ws_ob_update_manager_test.go
index 5c2ca326..5b4c3100 100644
--- a/exchanges/gateio/ws_ob_update_manager_test.go
+++ b/exchanges/gateio/ws_ob_update_manager_test.go
@@ -102,7 +102,7 @@ func TestSyncOrderbook(t *testing.T) {
 
 	e := new(Exchange)
 	require.NoError(t, testexch.Setup(e), "Setup must not error")
-	require.NoError(t, e.UpdateTradablePairs(t.Context(), false))
+	require.NoError(t, e.UpdateTradablePairs(t.Context()))
 
 	// Add dummy subscription so that it can be matched and a limit/level can be extracted for initial orderbook sync spot.
 	err := e.Websocket.AddSubscriptions(nil, &subscription.Subscription{Channel: subscription.OrderbookChannel, Interval: kline.HundredMilliseconds})
@@ -140,7 +140,7 @@ func TestApplyPendingUpdates(t *testing.T) {
 
 	e := new(Exchange)
 	require.NoError(t, testexch.Setup(e), "Setup must not error")
-	require.NoError(t, e.UpdateTradablePairs(t.Context(), false))
+	require.NoError(t, e.UpdateTradablePairs(t.Context()))
 
 	m := newWsOBUpdateManager(defaultWSSnapshotSyncDelay)
 	pair := currency.NewPair(currency.LTC, currency.USDT)
@@ -180,7 +180,7 @@ func TestApplyOrderbookUpdate(t *testing.T) {
 
 	e := new(Exchange)
 	require.NoError(t, testexch.Setup(e), "Setup must not error")
-	require.NoError(t, e.UpdateTradablePairs(t.Context(), false))
+	require.NoError(t, e.UpdateTradablePairs(t.Context()))
 
 	pair := currency.NewBTCUSDT()
 
diff --git a/exchanges/gemini/gemini_wrapper.go b/exchanges/gemini/gemini_wrapper.go
index dd50eb9c..d2c99e2a 100644
--- a/exchanges/gemini/gemini_wrapper.go
+++ b/exchanges/gemini/gemini_wrapper.go
@@ -204,13 +204,12 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	pairs, err := e.FetchTradablePairs(ctx, asset.Spot)
 	if err != nil {
 		return err
 	}
-	err = e.UpdatePairs(pairs, asset.Spot, false, forceUpdate)
-	if err != nil {
+	if err := e.UpdatePairs(pairs, asset.Spot, false); err != nil {
 		return err
 	}
 	return e.EnsureOnePairEnabled()
diff --git a/exchanges/hitbtc/hitbtc_test.go b/exchanges/hitbtc/hitbtc_test.go
index d3ea09f4..61485a0f 100644
--- a/exchanges/hitbtc/hitbtc_test.go
+++ b/exchanges/hitbtc/hitbtc_test.go
@@ -52,7 +52,7 @@ func TestMain(m *testing.M) {
 		e.SetCredentials(apiKey, apiSecret, "", "", "", "")
 	}
 
-	if err := e.UpdateTradablePairs(context.Background(), false); err != nil {
+	if err := e.UpdateTradablePairs(context.Background()); err != nil {
 		log.Fatalf("HitBTC UpdateTradablePairs error: %s", err)
 	}
 
diff --git a/exchanges/hitbtc/hitbtc_wrapper.go b/exchanges/hitbtc/hitbtc_wrapper.go
index 8ee6066a..2b77e8e3 100644
--- a/exchanges/hitbtc/hitbtc_wrapper.go
+++ b/exchanges/hitbtc/hitbtc_wrapper.go
@@ -198,13 +198,12 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, _ asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	pairs, err := e.FetchTradablePairs(ctx, asset.Spot)
 	if err != nil {
 		return err
 	}
-	err = e.UpdatePairs(pairs, asset.Spot, false, forceUpdate)
-	if err != nil {
+	if err := e.UpdatePairs(pairs, asset.Spot, false); err != nil {
 		return err
 	}
 	return e.EnsureOnePairEnabled()
diff --git a/exchanges/huobi/huobi_wrapper.go b/exchanges/huobi/huobi_wrapper.go
index 5ab68c75..658af25f 100644
--- a/exchanges/huobi/huobi_wrapper.go
+++ b/exchanges/huobi/huobi_wrapper.go
@@ -316,15 +316,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assets := e.GetAssetTypes(false)
 	for x := range assets {
 		pairs, err := e.FetchTradablePairs(ctx, assets[x])
 		if err != nil {
 			return err
 		}
-		err = e.UpdatePairs(pairs, assets[x], false, forceUpdate)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, assets[x], false); err != nil {
 			return err
 		}
 	}
diff --git a/exchanges/interfaces.go b/exchanges/interfaces.go
index ad9ccfec..f05c1d36 100644
--- a/exchanges/interfaces.go
+++ b/exchanges/interfaces.go
@@ -47,7 +47,7 @@ type IBotExchange interface {
 	GetCachedOrderbook(p currency.Pair, a asset.Item) (*orderbook.Book, error)
 	UpdateOrderbook(ctx context.Context, p currency.Pair, a asset.Item) (*orderbook.Book, error)
 	FetchTradablePairs(ctx context.Context, a asset.Item) (currency.Pairs, error)
-	UpdateTradablePairs(ctx context.Context, forceUpdate bool) error
+	UpdateTradablePairs(ctx context.Context) error
 	GetEnabledPairs(a asset.Item) (currency.Pairs, error)
 	GetAvailablePairs(a asset.Item) (currency.Pairs, error)
 	GetPairFormat(asset.Item, bool) (currency.PairFormat, error)
diff --git a/exchanges/kraken/kraken_wrapper.go b/exchanges/kraken/kraken_wrapper.go
index 5c4f3089..fa9a7be0 100644
--- a/exchanges/kraken/kraken_wrapper.go
+++ b/exchanges/kraken/kraken_wrapper.go
@@ -353,15 +353,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 }
 
 // UpdateTradablePairs updates the exchanges available pairs and stores them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assets := e.GetAssetTypes(false)
 	for x := range assets {
 		pairs, err := e.FetchTradablePairs(ctx, assets[x])
 		if err != nil {
 			return err
 		}
-		err = e.UpdatePairs(pairs, assets[x], false, forceUpdate)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, assets[x], false); err != nil {
 			return err
 		}
 	}
diff --git a/exchanges/kucoin/kucoin_test.go b/exchanges/kucoin/kucoin_test.go
index aa425799..d15e384c 100644
--- a/exchanges/kucoin/kucoin_test.go
+++ b/exchanges/kucoin/kucoin_test.go
@@ -2933,7 +2933,7 @@ func TestGetFundingHistory(t *testing.T) {
 }
 
 func getFirstTradablePairOfAssets(ctx context.Context) {
-	if err := e.UpdateTradablePairs(ctx, true); err != nil {
+	if err := e.UpdateTradablePairs(ctx); err != nil {
 		log.Fatalf("Kucoin error while updating tradable pairs. %v", err)
 	}
 	enabledPairs, err := e.GetEnabledPairs(asset.Spot)
diff --git a/exchanges/kucoin/kucoin_wrapper.go b/exchanges/kucoin/kucoin_wrapper.go
index ae9b585f..92c24260 100644
--- a/exchanges/kucoin/kucoin_wrapper.go
+++ b/exchanges/kucoin/kucoin_wrapper.go
@@ -269,18 +269,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, assetType asset.Item)
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assets := e.GetAssetTypes(true)
 	for a := range assets {
 		pairs, err := e.FetchTradablePairs(ctx, assets[a])
 		if err != nil {
 			return err
 		}
-		if len(pairs) == 0 {
-			return fmt.Errorf("%v; no tradable pairs", currency.ErrCurrencyPairsEmpty)
-		}
-		err = e.UpdatePairs(pairs, assets[a], false, forceUpdate)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, assets[a], false); err != nil {
 			return err
 		}
 	}
diff --git a/exchanges/lbank/lbank_wrapper.go b/exchanges/lbank/lbank_wrapper.go
index c61d8999..c93a71ab 100644
--- a/exchanges/lbank/lbank_wrapper.go
+++ b/exchanges/lbank/lbank_wrapper.go
@@ -142,13 +142,12 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, _ asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	pairs, err := e.FetchTradablePairs(ctx, asset.Spot)
 	if err != nil {
 		return err
 	}
-	err = e.UpdatePairs(pairs, asset.Spot, false, forceUpdate)
-	if err != nil {
+	if err := e.UpdatePairs(pairs, asset.Spot, false); err != nil {
 		return err
 	}
 	return e.EnsureOnePairEnabled()
diff --git a/exchanges/okx/okx_wrapper.go b/exchanges/okx/okx_wrapper.go
index b852af0c..2b046572 100644
--- a/exchanges/okx/okx_wrapper.go
+++ b/exchanges/okx/okx_wrapper.go
@@ -285,15 +285,14 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, a asset.Item) (curren
 }
 
 // UpdateTradablePairs updates the exchanges available pairs and stores them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	assetTypes := e.GetAssetTypes(true)
 	for i := range assetTypes {
 		pairs, err := e.FetchTradablePairs(ctx, assetTypes[i])
 		if err != nil {
 			return fmt.Errorf("%w for asset %v", err, assetTypes[i])
 		}
-		err = e.UpdatePairs(pairs, assetTypes[i], false, forceUpdate)
-		if err != nil {
+		if err := e.UpdatePairs(pairs, assetTypes[i], false); err != nil {
 			return fmt.Errorf("%w for asset %v", err, assetTypes[i])
 		}
 	}
diff --git a/exchanges/poloniex/poloniex_wrapper.go b/exchanges/poloniex/poloniex_wrapper.go
index 17e1691b..00adea50 100644
--- a/exchanges/poloniex/poloniex_wrapper.go
+++ b/exchanges/poloniex/poloniex_wrapper.go
@@ -214,13 +214,12 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, _ asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpgrade bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	pairs, err := e.FetchTradablePairs(ctx, asset.Spot)
 	if err != nil {
 		return err
 	}
-	err = e.UpdatePairs(pairs, asset.Spot, false, forceUpgrade)
-	if err != nil {
+	if err := e.UpdatePairs(pairs, asset.Spot, false); err != nil {
 		return err
 	}
 	return e.EnsureOnePairEnabled()
diff --git a/exchanges/sharedtestvalues/customex.go b/exchanges/sharedtestvalues/customex.go
index a1028206..fa8f0f34 100644
--- a/exchanges/sharedtestvalues/customex.go
+++ b/exchanges/sharedtestvalues/customex.go
@@ -30,7 +30,7 @@ type CustomEx struct {
 }
 
 // Setup is a mock method for CustomEx
-func (c *CustomEx) Setup(_ *config.Exchange) error {
+func (c *CustomEx) Setup(*config.Exchange) error {
 	return nil
 }
 
@@ -53,62 +53,62 @@ func (c *CustomEx) SetEnabled(bool) {
 }
 
 // ValidateAPICredentials is a mock method for CustomEx
-func (c *CustomEx) ValidateAPICredentials(_ context.Context, _ asset.Item) error {
+func (c *CustomEx) ValidateAPICredentials(context.Context, asset.Item) error {
 	return nil
 }
 
 // UpdateTickers is a mock method for CustomEx
-func (c *CustomEx) UpdateTickers(_ context.Context, _ asset.Item) error {
+func (c *CustomEx) UpdateTickers(context.Context, asset.Item) error {
 	return nil
 }
 
 // UpdateTicker is a mock method for CustomEx
-func (c *CustomEx) UpdateTicker(_ context.Context, _ currency.Pair, _ asset.Item) (*ticker.Price, error) {
+func (c *CustomEx) UpdateTicker(context.Context, currency.Pair, asset.Item) (*ticker.Price, error) {
 	return nil, nil
 }
 
 // UpdateOrderbook is a mock method for CustomEx
-func (c *CustomEx) UpdateOrderbook(_ context.Context, _ currency.Pair, _ asset.Item) (*orderbook.Book, error) {
+func (c *CustomEx) UpdateOrderbook(context.Context, currency.Pair, asset.Item) (*orderbook.Book, error) {
 	return nil, nil
 }
 
 // FetchTradablePairs is a mock method for CustomEx
-func (c *CustomEx) FetchTradablePairs(_ context.Context, _ asset.Item) (currency.Pairs, error) {
+func (c *CustomEx) FetchTradablePairs(context.Context, asset.Item) (currency.Pairs, error) {
 	return nil, nil
 }
 
 // UpdateTradablePairs is a mock method for CustomEx
-func (c *CustomEx) UpdateTradablePairs(_ context.Context, _ bool) error {
+func (c *CustomEx) UpdateTradablePairs(context.Context) error {
 	return nil
 }
 
 // GetEnabledPairs is a mock method for CustomEx
-func (c *CustomEx) GetEnabledPairs(_ asset.Item) (currency.Pairs, error) {
+func (c *CustomEx) GetEnabledPairs(asset.Item) (currency.Pairs, error) {
 	return nil, nil
 }
 
 // GetAvailablePairs is a mock method for CustomEx
-func (c *CustomEx) GetAvailablePairs(_ asset.Item) (currency.Pairs, error) {
+func (c *CustomEx) GetAvailablePairs(asset.Item) (currency.Pairs, error) {
 	return nil, nil
 }
 
 // UpdateAccountInfo is a mock method for CustomEx
-func (c *CustomEx) UpdateAccountInfo(_ context.Context, _ asset.Item) (account.Holdings, error) {
+func (c *CustomEx) UpdateAccountInfo(context.Context, asset.Item) (account.Holdings, error) {
 	return account.Holdings{}, nil
 }
 
 // SetPairs is a mock method for CustomEx
-func (c *CustomEx) SetPairs(_ currency.Pairs, _ asset.Item, _ bool) error {
+func (c *CustomEx) SetPairs(currency.Pairs, asset.Item, bool) error {
 	return nil
 }
 
 // GetAssetTypes is a mock method for CustomEx
-func (c *CustomEx) GetAssetTypes(_ bool) asset.Items {
+func (c *CustomEx) GetAssetTypes(bool) asset.Items {
 	return nil
 }
 
 // GetRecentTrades is a mock method for CustomEx
-func (c *CustomEx) GetRecentTrades(_ context.Context, _ currency.Pair, _ asset.Item) ([]trade.Data, error) {
+func (c *CustomEx) GetRecentTrades(context.Context, currency.Pair, asset.Item) ([]trade.Data, error) {
 	return nil, nil
 }
 
@@ -133,7 +133,7 @@ func (c *CustomEx) GetServerTime(context.Context, asset.Item) (time.Time, error)
 }
 
 // GetFeeByType is a mock method for CustomEx
-func (c *CustomEx) GetFeeByType(_ context.Context, _ *exchange.FeeBuilder) (float64, error) {
+func (c *CustomEx) GetFeeByType(context.Context, *exchange.FeeBuilder) (float64, error) {
 	return 0.0, nil
 }
 
@@ -153,42 +153,42 @@ func (c *CustomEx) FormatWithdrawPermissions() string {
 }
 
 // SupportsWithdrawPermissions is a mock method for CustomEx
-func (c *CustomEx) SupportsWithdrawPermissions(_ uint32) bool {
+func (c *CustomEx) SupportsWithdrawPermissions(uint32) bool {
 	return false
 }
 
 // GetAccountFundingHistory is a mock method for CustomEx
-func (c *CustomEx) GetAccountFundingHistory(_ context.Context) ([]exchange.FundingHistory, error) {
+func (c *CustomEx) GetAccountFundingHistory(context.Context) ([]exchange.FundingHistory, error) {
 	return nil, nil
 }
 
 // SubmitOrder is a mock method for CustomEx
-func (c *CustomEx) SubmitOrder(_ context.Context, _ *order.Submit) (*order.SubmitResponse, error) {
+func (c *CustomEx) SubmitOrder(context.Context, *order.Submit) (*order.SubmitResponse, error) {
 	return nil, nil
 }
 
 // ModifyOrder is a mock method for CustomEx
-func (c *CustomEx) ModifyOrder(_ context.Context, _ *order.Modify) (*order.ModifyResponse, error) {
+func (c *CustomEx) ModifyOrder(context.Context, *order.Modify) (*order.ModifyResponse, error) {
 	return nil, nil
 }
 
 // CancelOrder is a mock method for CustomEx
-func (c *CustomEx) CancelOrder(_ context.Context, _ *order.Cancel) error {
+func (c *CustomEx) CancelOrder(context.Context, *order.Cancel) error {
 	return nil
 }
 
 // CancelBatchOrders is a mock method for CustomEx
-func (c *CustomEx) CancelBatchOrders(_ context.Context, _ []order.Cancel) (*order.CancelBatchResponse, error) {
+func (c *CustomEx) CancelBatchOrders(context.Context, []order.Cancel) (*order.CancelBatchResponse, error) {
 	return nil, nil
 }
 
 // CancelAllOrders is a mock method for CustomEx
-func (c *CustomEx) CancelAllOrders(_ context.Context, _ *order.Cancel) (order.CancelAllResponse, error) {
+func (c *CustomEx) CancelAllOrders(context.Context, *order.Cancel) (order.CancelAllResponse, error) {
 	return order.CancelAllResponse{}, nil
 }
 
 // GetOrderInfo is a mock method for CustomEx
-func (c *CustomEx) GetOrderInfo(_ context.Context, _ string, _ currency.Pair, _ asset.Item) (*order.Detail, error) {
+func (c *CustomEx) GetOrderInfo(context.Context, string, currency.Pair, asset.Item) (*order.Detail, error) {
 	return nil, nil
 }
 
@@ -198,37 +198,37 @@ func (c *CustomEx) GetDepositAddress(_ context.Context, _ currency.Code, _, _ st
 }
 
 // GetOrderHistory is a mock method for CustomEx
-func (c *CustomEx) GetOrderHistory(_ context.Context, _ *order.MultiOrderRequest) (order.FilteredOrders, error) {
+func (c *CustomEx) GetOrderHistory(context.Context, *order.MultiOrderRequest) (order.FilteredOrders, error) {
 	return nil, nil
 }
 
 // GetWithdrawalsHistory is a mock method for CustomEx
-func (c *CustomEx) GetWithdrawalsHistory(_ context.Context, _ currency.Code, _ asset.Item) ([]exchange.WithdrawalHistory, error) {
+func (c *CustomEx) GetWithdrawalsHistory(context.Context, currency.Code, asset.Item) ([]exchange.WithdrawalHistory, error) {
 	return []exchange.WithdrawalHistory{}, nil
 }
 
 // GetActiveOrders is a mock method for CustomEx
-func (c *CustomEx) GetActiveOrders(_ context.Context, _ *order.MultiOrderRequest) (order.FilteredOrders, error) {
+func (c *CustomEx) GetActiveOrders(context.Context, *order.MultiOrderRequest) (order.FilteredOrders, error) {
 	return []order.Detail{}, nil
 }
 
 // WithdrawCryptocurrencyFunds is a mock method for CustomEx
-func (c *CustomEx) WithdrawCryptocurrencyFunds(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
+func (c *CustomEx) WithdrawCryptocurrencyFunds(context.Context, *withdraw.Request) (*withdraw.ExchangeResponse, error) {
 	return nil, nil
 }
 
 // WithdrawFiatFunds is a mock method for CustomEx
-func (c *CustomEx) WithdrawFiatFunds(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
+func (c *CustomEx) WithdrawFiatFunds(context.Context, *withdraw.Request) (*withdraw.ExchangeResponse, error) {
 	return nil, nil
 }
 
 // WithdrawFiatFundsToInternationalBank is a mock method for CustomEx
-func (c *CustomEx) WithdrawFiatFundsToInternationalBank(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
+func (c *CustomEx) WithdrawFiatFundsToInternationalBank(context.Context, *withdraw.Request) (*withdraw.ExchangeResponse, error) {
 	return nil, nil
 }
 
 // SetHTTPClientUserAgent is a mock method for CustomEx
-func (c *CustomEx) SetHTTPClientUserAgent(_ string) error {
+func (c *CustomEx) SetHTTPClientUserAgent(string) error {
 	return nil
 }
 
@@ -238,7 +238,7 @@ func (c *CustomEx) GetHTTPClientUserAgent() (string, error) {
 }
 
 // SetClientProxyAddress is a mock method for CustomEx
-func (c *CustomEx) SetClientProxyAddress(_ string) error {
+func (c *CustomEx) SetClientProxyAddress(string) error {
 	return nil
 }
 
@@ -258,7 +258,7 @@ func (c *CustomEx) GetBase() *exchange.Base {
 }
 
 // SupportsAsset is a mock method for CustomEx
-func (c *CustomEx) SupportsAsset(_ asset.Item) bool {
+func (c *CustomEx) SupportsAsset(asset.Item) bool {
 	return false
 }
 
@@ -298,17 +298,17 @@ func (c *CustomEx) SupportsWebsocket() bool {
 }
 
 // SubscribeToWebsocketChannels is a mock method for CustomEx
-func (c *CustomEx) SubscribeToWebsocketChannels(_ subscription.List) error {
+func (c *CustomEx) SubscribeToWebsocketChannels(subscription.List) error {
 	return nil
 }
 
 // UnsubscribeToWebsocketChannels is a mock method for CustomEx
-func (c *CustomEx) UnsubscribeToWebsocketChannels(_ subscription.List) error {
+func (c *CustomEx) UnsubscribeToWebsocketChannels(subscription.List) error {
 	return nil
 }
 
 // IsAssetWebsocketSupported is a mock method for CustomEx
-func (c *CustomEx) IsAssetWebsocketSupported(_ asset.Item) bool {
+func (c *CustomEx) IsAssetWebsocketSupported(asset.Item) bool {
 	return false
 }
 
@@ -318,12 +318,12 @@ func (c *CustomEx) FlushWebsocketChannels() error {
 }
 
 // AuthenticateWebsocket is a mock method for CustomEx
-func (c *CustomEx) AuthenticateWebsocket(_ context.Context) error {
+func (c *CustomEx) AuthenticateWebsocket(context.Context) error {
 	return nil
 }
 
 // GetOrderExecutionLimits is a mock method for CustomEx
-func (c *CustomEx) GetOrderExecutionLimits(_ asset.Item, _ currency.Pair) (limits.MinMaxLevel, error) {
+func (c *CustomEx) GetOrderExecutionLimits(asset.Item, currency.Pair) (limits.MinMaxLevel, error) {
 	return limits.MinMaxLevel{}, nil
 }
 
@@ -333,17 +333,17 @@ func (c *CustomEx) CheckOrderExecutionLimits(_ asset.Item, _ currency.Pair, _, _
 }
 
 // UpdateOrderExecutionLimits is a mock method for CustomEx
-func (c *CustomEx) UpdateOrderExecutionLimits(_ context.Context, _ asset.Item) error {
+func (c *CustomEx) UpdateOrderExecutionLimits(context.Context, asset.Item) error {
 	return nil
 }
 
 // GetHistoricalFundingRates returns funding rates for a given asset and currency for a time period
-func (c *CustomEx) GetHistoricalFundingRates(_ context.Context, _ *fundingrate.HistoricalRatesRequest) (*fundingrate.HistoricalRates, error) {
+func (c *CustomEx) GetHistoricalFundingRates(context.Context, *fundingrate.HistoricalRatesRequest) (*fundingrate.HistoricalRates, error) {
 	return nil, nil
 }
 
 // GetLatestFundingRates returns the latest funding rates data
-func (c *CustomEx) GetLatestFundingRates(_ context.Context, _ *fundingrate.LatestRateRequest) ([]fundingrate.LatestRateResponse, error) {
+func (c *CustomEx) GetLatestFundingRates(context.Context, *fundingrate.LatestRateRequest) ([]fundingrate.LatestRateResponse, error) {
 	return nil, nil
 }
 
diff --git a/exchanges/yobit/yobit_wrapper.go b/exchanges/yobit/yobit_wrapper.go
index 327243de..5caeefcd 100644
--- a/exchanges/yobit/yobit_wrapper.go
+++ b/exchanges/yobit/yobit_wrapper.go
@@ -126,13 +126,12 @@ func (e *Exchange) FetchTradablePairs(ctx context.Context, _ asset.Item) (curren
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (e *Exchange) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
+func (e *Exchange) UpdateTradablePairs(ctx context.Context) error {
 	pairs, err := e.FetchTradablePairs(ctx, asset.Spot)
 	if err != nil {
 		return err
 	}
-	err = e.UpdatePairs(pairs, asset.Spot, false, forceUpdate)
-	if err != nil {
+	if err := e.UpdatePairs(pairs, asset.Spot, false); err != nil {
 		return err
 	}
 	return e.EnsureOnePairEnabled()
diff --git a/internal/testing/exchange/exchange.go b/internal/testing/exchange/exchange.go
index 4e348843..ada3ee8c 100644
--- a/internal/testing/exchange/exchange.go
+++ b/internal/testing/exchange/exchange.go
@@ -226,7 +226,7 @@ func UpdatePairsOnce(tb testing.TB, e exchange.IBotExchange) {
 		return
 	}
 
-	err := e.UpdateTradablePairs(tb.Context(), true)
+	err := e.UpdateTradablePairs(tb.Context())
 	require.NoError(tb, err, "UpdateTradablePairs must not error")
 
 	cache := new(currency.PairsManager)