Add ramp plugin amount type filtering

Author: samholmes

src/components/scenes/TradeCreateScene.tsx

@@ -11,7 +11,10 @@ import { FLAG_LOGO_URL } from '../../constants/CdnConstants'
 import { COUNTRY_CODES, FIAT_COUNTRY } from '../../constants/CountryConstants'
 import { useHandler } from '../../hooks/useHandler'
 import { useRampQuotes } from '../../hooks/useRampQuotes'
-import { useSupportedPlugins } from '../../hooks/useSupportedPlugins'
+import {
+  type SupportedPluginResult,
+  useSupportedPlugins
+} from '../../hooks/useSupportedPlugins'
 import { useWatch } from '../../hooks/useWatch'
 import { lstrings } from '../../locales/strings'
 import type { RampQuoteRequest } from '../../plugins/ramps/rampPluginTypes'
@@ -49,6 +52,47 @@ export interface TradeCreateParams {
 
 interface Props extends BuyTabSceneProps<'pluginListBuy'> {}
 
+// Helper function to determine which input types should be disabled
+interface AmountTypeSupport {
+  fiatInputDisabled: boolean
+  cryptoInputDisabled: boolean
+}
+
+function getAmountTypeSupport(
+  supportedPlugins: SupportedPluginResult[]
+): AmountTypeSupport {
+  if (supportedPlugins.length === 0) {
+    return { fiatInputDisabled: false, cryptoInputDisabled: false }
+  }
+
+  // Collect all supported amount types from all plugins
+  const allSupportedTypes = new Set<'fiat' | 'crypto'>()
+
+  for (const { supportResult } of supportedPlugins) {
+    if (supportResult.supportedAmountTypes != null) {
+      for (const type of supportResult.supportedAmountTypes) {
+        allSupportedTypes.add(type)
+      }
+    } else {
+      // If a plugin doesn't specify supported types, assume both are supported
+      allSupportedTypes.add('fiat')
+      allSupportedTypes.add('crypto')
+    }
+  }
+
+  // If all plugins only support fiat, disable crypto input
+  const onlyFiat =
+    allSupportedTypes.has('fiat') && !allSupportedTypes.has('crypto')
+  // If all plugins only support crypto, disable fiat input
+  const onlyCrypto =
+    allSupportedTypes.has('crypto') && !allSupportedTypes.has('fiat')
+
+  return {
+    fiatInputDisabled: onlyCrypto,
+    cryptoInputDisabled: onlyFiat
+  }
+}
+
 export const TradeCreateScene = (props: Props): React.ReactElement => {
   const { navigation, route } = props
   const { regionCode: initialRegionCode, forcedWalletResult } =
@@ -223,13 +267,17 @@ export const TradeCreateScene = (props: Props): React.ReactElement => {
   } = useRampQuotes({
     rampQuoteRequest,
     plugins: Object.fromEntries(
-      supportedPlugins.map(plugin => [plugin.pluginId, plugin])
+      supportedPlugins.map(result => [result.plugin.pluginId, result.plugin])
     )
   })
 
   // Get the best quote
   const bestQuote = sortedQuotes[0]
 
+  // Determine which input types should be disabled
+  const { fiatInputDisabled, cryptoInputDisabled } =
+    getAmountTypeSupport(supportedPlugins)
+
   // Calculate exchange rate from best quote
   const quoteExchangeRate = React.useMemo(() => {
     if (!bestQuote?.cryptoAmount || !bestQuote.fiatAmount) return 0
@@ -516,6 +564,7 @@ export const TradeCreateScene = (props: Props): React.ReactElement => {
                 keyboardType="decimal-pad"
                 numeric
                 showSpinner={isFetchingQuotes && lastUsedInput === 'crypto'}
+                disabled={fiatInputDisabled}
               />
             </InputContainer>
           </InputRow>
@@ -545,6 +594,7 @@ export const TradeCreateScene = (props: Props): React.ReactElement => {
                 keyboardType="decimal-pad"
                 numeric
                 showSpinner={isFetchingQuotes && lastUsedInput === 'fiat'}
+                disabled={cryptoInputDisabled}
               />
               {/* MAX Button */}
               <MaxButton active={isMaxAmount} onPress={handleMaxPress}>

src/components/scenes/TradeOptionSelectScene.tsx

@@ -65,7 +65,7 @@ export const TradeOptionSelectScene = (props: Props): React.JSX.Element => {
 
   // Use supported plugins
   const pluginsToUse = Object.fromEntries(
-    supportedPlugins.map(plugin => [plugin.pluginId, plugin])
+    supportedPlugins.map(result => [result.plugin.pluginId, result.plugin])
   )
 
   // Use the ramp quotes hook

src/hooks/useSupportedPlugins.ts

@@ -5,7 +5,8 @@ import * as React from 'react'
 import type { FiatPluginRegionCode } from '../plugins/gui/fiatPluginTypes'
 import type {
   RampCheckSupportRequest,
-  RampPlugin
+  RampPlugin,
+  RampSupportResult
 } from '../plugins/ramps/rampPluginTypes'
 
 interface UseSupportedPluginsParams {
@@ -21,8 +22,13 @@ interface UseSupportedPluginsParams {
   direction?: 'buy' | 'sell'
 }
 
+export interface SupportedPluginResult {
+  plugin: RampPlugin
+  supportResult: RampSupportResult
+}
+
 interface UseSupportedPluginsResult {
-  supportedPlugins: RampPlugin[]
+  supportedPlugins: SupportedPluginResult[]
   isLoading: boolean
   error: Error | null
 }
@@ -60,7 +66,7 @@ export const useSupportedPlugins = ({
     data: supportedPlugins = [],
     isLoading,
     error
-  } = useQuery<RampPlugin[]>({
+  } = useQuery<SupportedPluginResult[]>({
     queryKey,
     queryFn: async () => {
       // Early return if required params are missing
@@ -90,10 +96,10 @@ export const useSupportedPlugins = ({
       const supportChecks = await Promise.all(
         Object.values(plugins).map(async plugin => {
           try {
-            const result = await plugin.checkSupport(checkSupportRequest)
+            const supportResult = await plugin.checkSupport(checkSupportRequest)
             return {
               plugin,
-              supported: result.supported
+              supportResult
             }
           } catch (error) {
             console.warn(
@@ -102,16 +108,14 @@ export const useSupportedPlugins = ({
             )
             return {
               plugin,
-              supported: false
+              supportResult: { supported: false }
             }
           }
         })
       )
 
       // Filter only supported plugins
-      return supportChecks
-        .filter(check => check.supported)
-        .map(check => check.plugin)
+      return supportChecks.filter(check => check.supportResult.supported)
     },
     enabled: Boolean(
       selectedWallet && selectedCrypto && selectedFiatCurrencyCode && regionCode

src/plugins/ramps/banxa/banxaRampPlugin.ts

@@ -867,7 +867,10 @@ export const banxaRampPlugin: RampPluginFactory = (
           return { supported: false }
         }
 
-        return { supported: true }
+        return {
+          supported: true,
+          supportedAmountTypes: ['fiat', 'crypto']
+        }
       } catch (error) {
         console.error('Banxa: Error in checkSupport:', error)
         return { supported: false }

src/plugins/ramps/bity/bityRampPlugin.ts

@@ -694,7 +694,10 @@ export const bityRampPlugin = (pluginConfig: RampPluginConfig): RampPlugin => {
         }
 
         // All checks passed
-        return { supported: true }
+        return {
+          supported: true,
+          supportedAmountTypes: ['fiat', 'crypto']
+        }
       } catch (error) {
         // Log error and return false for any unexpected errors
         console.error('Bity checkSupport error:', error)

src/plugins/ramps/paybis/paybisRampPlugin.ts

@@ -759,7 +759,10 @@ export const paybisRampPlugin: RampPluginFactory = (
         }
 
         // If we get here, it's supported
-        return { supported: true }
+        return {
+          supported: true,
+          supportedAmountTypes: ['fiat', 'crypto']
+        }
       } catch (error) {
         // Only throw for actual errors (network issues, etc)
         // Never throw for unsupported combinations

src/plugins/ramps/rampPluginTypes.ts

@@ -31,6 +31,8 @@ export interface RampCheckSupportRequest {
 
 export interface RampSupportResult {
   supported: boolean
+  // Indicates which amount types are supported by this plugin
+  supportedAmountTypes?: Array<'fiat' | 'crypto'>
 }
 
 export interface RampQuoteRequest {

src/plugins/ramps/revolut/revolutRampPlugin.ts

@@ -171,7 +171,10 @@ export const revolutRampPlugin: RampPluginFactory = (
           assetMap
         })
 
-        return { supported: assetsSupported }
+        return {
+          supported: assetsSupported,
+          supportedAmountTypes: assetsSupported ? ['fiat'] : undefined
+        }
       } catch (error) {
         console.error('Failed to check Revolut support:', error)
         return { supported: false }
@@ -200,13 +203,7 @@ export const revolutRampPlugin: RampPluginFactory = (
         return []
       }
 
-      // Only support fiat amount type (Revolut requires fiat-based quotes)
-      if (request.amountType !== 'fiat') {
-        throw new FiatProviderError({
-          providerId: pluginId,
-          errorType: 'amountTypeUnsupported'
-        })
-      }
+      // Amount type check is now handled in checkSupport phase
 
       try {
         // Fetch provider configuration (will use cache if valid)

src/plugins/ramps/simplex/simplexRampPlugin.ts

@@ -575,7 +575,10 @@ export const simplexRampPlugin: RampPluginFactory = (
         }
 
         // All validations passed
-        return { supported: true }
+        return {
+          supported: true,
+          supportedAmountTypes: ['fiat', 'crypto']
+        }
       } catch (error) {
         // Only throw for actual errors (network issues, etc)
         // Never throw for unsupported combinations