Kraken: Fix GetLatestFundingRates requiring pair enabled (#1522)

* Kraken: Fix GetLatestFundingRates requiring pair enabled

* Tests: Add latestRateRequests to all asset tests

cmd/exchange_wrapper_standards/exchange_wrapper_standards_test.go

@@ -185,17 +185,15 @@ func executeExchangeWrapperTests(ctx context.Context, t *testing.T, exch exchang
 		var assetLen int
 		for y := 0; y < method.Type().NumIn(); y++ {
 			input := method.Type().In(y)
-			if input.AssignableTo(assetParam) ||
-				input.AssignableTo(orderSubmitParam) ||
-				input.AssignableTo(orderModifyParam) ||
-				input.AssignableTo(orderCancelParam) ||
-				input.AssignableTo(orderCancelsParam) ||
-				input.AssignableTo(pairKeySliceParam) ||
-				input.AssignableTo(getOrdersRequestParam) ||
-				input.AssignableTo(pairKeySliceParam) {
-				// this allows wrapper functions that support assets types
-				// to be tested with all supported assets
-				assetLen = len(assetParams) - 1
+			for _, t := range []reflect.Type{
+				assetParam, orderSubmitParam, orderModifyParam, orderCancelParam, orderCancelsParam, pairKeySliceParam, getOrdersRequestParam, latestRateRequest,
+			} {
+				if input.AssignableTo(t) {
+					// this allows wrapper functions that support assets types
+					// to be tested with all supported assets
+					assetLen = len(assetParams) - 1
+					break
+				}
 			}
 		}
 		tt := time.Now()

currency/manager.go

@@ -335,6 +335,29 @@ func (p *PairsManager) EnablePair(a asset.Item, pair Pair) error {
 	return nil
 }
 
+// IsPairAvailable checks if a pair is available for a given asset type
+func (p *PairsManager) IsPairAvailable(pair Pair, a asset.Item) (bool, error) {
+	if !a.IsValid() {
+		return false, fmt.Errorf("%s %w", a, asset.ErrNotSupported)
+	}
+
+	if pair.IsEmpty() {
+		return false, ErrCurrencyPairEmpty
+	}
+
+	p.mutex.RLock()
+	defer p.mutex.RUnlock()
+
+	pairStore, err := p.getPairStoreRequiresLock(a)
+	if err != nil {
+		return false, err
+	}
+	if pairStore.AssetEnabled == nil {
+		return false, fmt.Errorf("%s %w", a, ErrAssetIsNil)
+	}
+	return *pairStore.AssetEnabled && pairStore.Available.Contains(pair, true), nil
+}
+
 // IsPairEnabled checks if a pair is enabled for an enabled asset type
 func (p *PairsManager) IsPairEnabled(pair Pair, a asset.Item) (bool, error) {
 	if !a.IsValid() {

currency/manager_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/common"
 	"github.com/thrasher-corp/gocryptotrader/common/convert"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
@@ -574,6 +575,41 @@ func TestFullStoreUnmarshalMarshal(t *testing.T) {
 	}
 }
 
+func TestIsPairAvailable(t *testing.T) {
+	t.Parallel()
+	pm := initTest(t)
+	cp := NewPairWithDelimiter("BTC", "USD", "-")
+	ok, err := pm.IsPairAvailable(cp, asset.Spot)
+	require.NoError(t, err, "IsPairAvailable must not error")
+	assert.True(t, ok, "IsPairAvailable should return correct value for an available and enabled pair")
+
+	ok, err = pm.IsPairAvailable(NewPair(SAFE, MOONRISE), asset.Spot)
+	require.NoError(t, err, "IsPairAvailable must not error")
+	assert.False(t, ok, "IsPairAvailable should return correct value for an non-existent")
+
+	ok, err = pm.IsPairAvailable(cp, asset.Futures)
+	require.NoError(t, err, "IsPairAvailable must not error")
+	assert.False(t, ok, "IsPairAvailable should return false for a disabled asset type")
+
+	cp = NewPairWithDelimiter("XRP", "DOGE", "-")
+	ok, err = pm.IsPairAvailable(cp, asset.Spot)
+	require.NoError(t, err, "IsPairAvailable must not error")
+	assert.False(t, ok, "IsPairAvailable should return false for non-existent pair")
+
+	_, err = pm.IsPairAvailable(cp, asset.PerpetualSwap)
+	assert.ErrorIs(t, err, ErrAssetNotFound, "Should error when asset is not found")
+
+	_, err = pm.IsPairAvailable(cp, asset.Item(1337))
+	assert.ErrorIs(t, err, asset.ErrNotSupported, "Should error when asset is not supported")
+
+	pm.Pairs[asset.PerpetualSwap] = &PairStore{}
+	_, err = pm.IsPairAvailable(cp, asset.PerpetualSwap)
+	assert.ErrorIs(t, err, ErrAssetIsNil, "Should error when store AssetEnabled is nil")
+
+	_, err = pm.IsPairAvailable(EMPTYPAIR, asset.PerpetualSwap)
+	assert.ErrorIs(t, err, ErrCurrencyPairEmpty, "Should error when currency pair is empty")
+}
+
 func TestIsPairEnabled(t *testing.T) {
 	t.Parallel()
 	pm := initTest(t)

exchanges/kraken/kraken_wrapper.go

@@ -1695,12 +1695,10 @@ func (k *Kraken) GetLatestFundingRates(ctx context.Context, r *fundingrate.Lates
 		return nil, fmt.Errorf("%w %v", asset.ErrNotSupported, r.Asset)
 	}
 	if !r.Pair.IsEmpty() {
-		_, isEnabled, err := k.MatchSymbolCheckEnabled(r.Pair.String(), r.Asset, r.Pair.Delimiter != "")
-		if err != nil && !errors.Is(err, currency.ErrPairNotFound) {
+		if ok, err := k.CurrencyPairs.IsPairAvailable(r.Pair, r.Asset); err != nil {
 			return nil, err
-		}
-		if !isEnabled {
-			return nil, fmt.Errorf("%w %v", currency.ErrPairNotEnabled, r.Pair)
+		} else if !ok {
+			return nil, currency.ErrPairNotContainedInAvailablePairs
 		}
 	}