Remove getSupportedAssets API from RampPlugin

Author: samholmes

docs/ramp-plugin-architecture.md

@@ -0,0 +1,207 @@
+# Ramp Plugin Architecture
+
+This document describes the simplified ramp plugin architecture for Edge React GUI, focusing on the streamlined approach after removing the `getSupportedAssets` method.
+
+## Overview
+
+The ramp plugin system provides a unified interface for integrating fiat on/off ramp providers (buy/sell cryptocurrency). The architecture has been simplified to reduce complexity and improve performance.
+
+## Architecture Flow
+
+### Previous Architecture (Complex)
+1. User selects crypto/fiat pair
+2. UI calls `useSupportedPlugins` hook
+3. Hook calls `getSupportedAssets` on each plugin
+4. UI filters to only supported plugins
+5. UI calls `fetchQuote` on supported plugins only
+6. Display quotes to user
+
+### Current Architecture (Simplified)
+1. User selects crypto/fiat pair
+2. UI gets all plugins from Redux
+3. UI calls `fetchQuote` on all plugins in parallel
+4. Plugins return empty array if unsupported
+5. Display quotes to user
+
+## Plugin Interface
+
+```typescript
+export interface RampPlugin {
+  readonly pluginId: string
+  readonly rampInfo: RampInfo
+
+  readonly fetchQuote: (
+    request: RampQuoteRequest,
+    opts?: unknown
+  ) => Promise<RampQuoteResult[]>
+}
+```
+
+### Key Changes
+- Removed `getSupportedAssets` method
+- All support checking happens inside `fetchQuote`
+- Return empty array `[]` for unsupported requests
+- Only throw errors for actual failures
+
+## Implementation Guide
+
+### Creating a Ramp Plugin
+
+```typescript
+export const myRampPlugin: RampPluginFactory = (config: RampPluginConfig) => {
+  const { account, navigation, onLogEvent, disklet } = config
+  
+  const plugin: RampPlugin = {
+    pluginId: 'myplugin',
+    rampInfo: {
+      partnerIcon: 'https://example.com/icon.png',
+      pluginDisplayName: 'My Plugin'
+    },
+    
+    fetchQuote: async (request: RampQuoteRequest): Promise<RampQuoteResult[]> => {
+      const {
+        direction,
+        regionCode,
+        fiatCurrencyCode,
+        displayCurrencyCode,
+        tokenId,
+        pluginId: currencyPluginId
+      } = request
+      
+      // 1. Check region support
+      if (!isRegionSupported(regionCode)) {
+        return [] // Not supported
+      }
+      
+      // 2. Check asset support
+      if (!isAssetSupported(currencyPluginId, tokenId)) {
+        return [] // Not supported
+      }
+      
+      // 3. Check fiat support
+      if (!isFiatSupported(fiatCurrencyCode)) {
+        return [] // Not supported
+      }
+      
+      // 4. Fetch quotes from provider
+      try {
+        const quotes = await fetchFromProvider(request)
+        return quotes.map(quote => convertToRampQuoteResult(quote))
+      } catch (error) {
+        // Only throw for actual errors
+        console.error(`Failed to fetch quotes: ${error}`)
+        throw error
+      }
+    }
+  }
+  
+  return plugin
+}
+```
+
+## UI Integration
+
+### TradeCreateScene
+
+```typescript
+export const TradeCreateScene = () => {
+  // Get all plugins directly from Redux
+  const rampPlugins = useSelector(state => state.rampPlugins.plugins)
+  const isPluginsLoading = useSelector(state => state.rampPlugins.isLoading)
+  
+  // Create quote request
+  const rampQuoteRequest: RampQuoteRequest = {
+    // ... request parameters
+  }
+  
+  // Fetch quotes from all plugins
+  const { quotes, isLoading, errors } = useRampQuotes({
+    rampQuoteRequest,
+    plugins: rampPlugins
+  })
+  
+  // Render UI
+  return (
+    // ... UI components
+  )
+}
+```
+
+### useRampQuotes Hook
+
+The hook handles:
+- Parallel quote fetching from all plugins
+- Filtering out empty results (unsupported)
+- Error handling and retry logic
+- Quote expiration and refresh
+- Result caching and deduplication
+
+## Benefits of Simplified Architecture
+
+1. **Performance**: All plugins check support and fetch quotes in a single parallel operation
+2. **Simplicity**: One method to implement instead of two
+3. **Reduced Latency**: No sequential support check followed by quote fetch
+4. **Better Error Handling**: Clear distinction between "not supported" (empty array) and "error" (exception)
+5. **Easier Testing**: Only one method to test per plugin
+6. **Less Code**: Removed entire `useSupportedPlugins` hook and related logic
+
+## Migration from Legacy Architecture
+
+See [Ramp Plugin Migration Guide](./ramp-plugin-migration-guide.md) for detailed migration instructions.
+
+## Best Practices
+
+1. **Return Empty Array**: Always return `[]` for unsupported requests, never throw
+2. **Fast Fail**: Check support conditions early in `fetchQuote` to avoid unnecessary API calls
+3. **Parallel Processing**: The UI fetches from all plugins in parallel, so optimize for quick responses
+4. **Error Logging**: Log support check failures for debugging but don't throw
+5. **Cache Support Data**: Cache any expensive support checks within the plugin if needed
+
+## Example Quote Flow
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant UI
+    participant Redux
+    participant Plugin1
+    participant Plugin2
+    
+    User->>UI: Select crypto/fiat pair
+    UI->>Redux: Get all plugins
+    Redux->>UI: Return plugins
+    
+    par Parallel Execution
+        UI->>Plugin1: fetchQuote(request)
+        UI->>Plugin2: fetchQuote(request)
+    end
+    
+    Plugin1->>UI: Return quotes or []
+    Plugin2->>UI: Return quotes or []
+    
+    UI->>User: Display available quotes
+```
+
+## Plugin State Management
+
+Plugins are initialized once when the app starts and stored in Redux:
+
+```typescript
+interface RampPluginState {
+  readonly isLoading: boolean
+  readonly plugins: Record<string, RampPlugin>
+}
+```
+
+The `RampPluginManager` component handles:
+- Loading plugin factories
+- Initializing plugins with configuration
+- Updating Redux state when ready
+
+## Future Considerations
+
+1. **Plugin Discovery**: Dynamic plugin loading based on user region
+2. **Quote Caching**: Shared quote cache across plugins
+3. **WebSocket Support**: Real-time quote updates
+4. **Plugin Versioning**: Support for multiple plugin versions
+5. **Analytics**: Unified analytics across all plugins

docs/ramp-plugin-migration-guide.md

@@ -376,37 +376,92 @@ const assets = await plugin.getSupportedAssets({
 
 The API remains the same, maintaining compatibility with existing code. Note that the method returns the asset map for the first supported payment type from the provided array.
 
-## Asset Discovery Integration
+## Removing getSupportedAssets
 
-The ramp plugin architecture includes a `getSupportedAssets` method that allows the UI to check which plugins support specific crypto/fiat/region combinations:
+The ramp plugin architecture has been simplified by removing the separate `getSupportedAssets` method. All support checking is now done within the `fetchQuote` method.
 
+### Migration Steps
+
+1. **Move all asset support logic from `getSupportedAssets` into `fetchQuote`**
+2. **Return an empty array `[]` from `fetchQuote` if the requested assets are not supported**
+3. **Only throw errors for actual failures (network issues, API errors, etc.)**
+4. **Remove the `getSupportedAssets` method entirely**
+
+### Example
+
+**Before:**
+```typescript
+getSupportedAssets: async (request) => {
+  const { direction, paymentTypes, regionCode } = request
+  
+  // Validate region
+  validateRegion(pluginId, regionCode, SUPPORTED_REGIONS)
+  
+  // Check country restrictions
+  if (regionCode.countryCode === 'GB') {
+    throw new FiatProviderError({ errorType: 'assetUnsupported' })
+  }
+  
+  // Return supported assets
+  return assetMap
+},
+
+fetchQuote: async (request) => {
+  // Fetch quotes...
+}
+```
+
+**After:**
+```typescript
+fetchQuote: async (request) => {
+  const { regionCode, direction } = request
+  
+  // Validate region
+  try {
+    validateRegion(pluginId, regionCode, SUPPORTED_REGIONS)
+  } catch (error) {
+    return [] // Return empty array for unsupported regions
+  }
+  
+  // Check country restrictions
+  if (regionCode.countryCode === 'GB') {
+    return [] // Return empty array for unsupported countries
+  }
+  
+  // Check if assets are supported
+  if (!isAssetSupported(request)) {
+    return [] // Return empty array for unsupported assets
+  }
+  
+  // Fetch quotes...
+}
+```
+
+### UI Integration
+
+The UI no longer needs a separate hook to check plugin support. Instead, it passes all plugins to `useRampQuotes`:
+
+**Before:**
 ```typescript
-// Usage in TradeCreateScene via custom hook
 import { useSupportedPlugins } from '../../hooks/useSupportedPlugins'
 
-const { 
-  data: supportedPlugins = [], 
-  isLoading: isCheckingSupport 
-} = useSupportedPlugins({
-  selectedWallet,
-  selectedCrypto,
-  selectedCryptoCurrencyCode,
-  selectedFiatCurrencyCode,
-  countryCode,
-  stateProvinceCode
-})
+const { data: supportedPlugins } = useSupportedPlugins({ ... })
+const quotes = useRampQuotes({ plugins: supportedPlugins })
+```
 
-// Only query supported plugins for quotes
-const quotePromises = supportedPlugins.map(async (plugin) => {
-  return await plugin.fetchQuote(rampQuoteRequest)
-})
+**After:**
+```typescript
+const rampPlugins = useSelector(state => state.rampPlugins.plugins)
+const quotes = useRampQuotes({ plugins: rampPlugins })
 ```
 
-The `useSupportedPlugins` hook:
-- Checks all payment types for comprehensive support
-- Caches results for 5 minutes to avoid excessive API calls
-- Filters plugins based on crypto/fiat/region support
-- Returns loading state for UI feedback
+### Benefits
+
+1. **Simplified Architecture**: Removes one entire method and hook from the system
+2. **Reduced Network Calls**: No separate support check before fetching quotes
+3. **Better Performance**: All plugins check support in parallel during quote fetching
+4. **Cleaner Code**: Less abstraction and indirection
+5. **Easier Plugin Development**: Plugin authors only need to implement one method
 
 ## Benefits