Integrate Phaze FX API, enforce $5 minimum

- Fully support non-USD fiats
- Simplify and making it look neater by using whole numbers for conversions.
- Global minimums from Phaze that are >$5 remain intact, e.g. XMR.

Author: Jon-edge

src/components/scenes/GiftCardPurchaseScene.tsx

@@ -15,13 +15,16 @@ import Ionicons from 'react-native-vector-icons/Ionicons'
 import { sprintf } from 'sprintf-js'
 import { v4 as uuidv4 } from 'uuid'
 
+import { getFiatSymbol } from '../../constants/WalletAndCurrencyConstants'
 import { ENV } from '../../env'
+import { displayFiatAmount } from '../../hooks/useFiatText'
 import { useGiftCardProvider } from '../../hooks/useGiftCardProvider'
 import { useHandler } from '../../hooks/useHandler'
 import { usePhazeBrand } from '../../hooks/usePhazeBrand'
 import { lstrings } from '../../locales/strings'
 import type {
   PhazeCreateOrderResponse,
+  PhazeFxRate,
   PhazeGiftCardBrand,
   PhazeToken
 } from '../../plugins/gift-cards/phazeGiftCardTypes'
@@ -163,6 +166,42 @@ export const GiftCardPurchaseScene: React.FC<Props> = props => {
     gcTime: 10 * 60 * 1000
   })
 
+  // Get cached FX rates (already loaded during provider initialization)
+  const fxRates = provider?.getCachedFxRates() ?? null
+
+  /**
+   * Convert USD amount to brand's currency using FX rates.
+   * Returns formatted string like "€5" or "$5.00" for USD brands.
+   */
+  const formatMinimumInBrandCurrency = React.useCallback(
+    (minimumUsd: number): string => {
+      const symbol = getFiatSymbol(brand.currency)
+
+      if (brand.currency === 'USD') {
+        return `${symbol}${displayFiatAmount(minimumUsd, 2)}`
+      }
+
+      if (fxRates == null) {
+        // Fallback to USD if rates not loaded
+        return `$${displayFiatAmount(minimumUsd, 2)}`
+      }
+
+      const rate = fxRates.find(
+        (r: PhazeFxRate) =>
+          r.fromCurrency === 'USD' && r.toCurrency === brand.currency
+      )
+      if (rate == null) {
+        // Fallback to USD if rate not found
+        return `$${displayFiatAmount(minimumUsd, 2)}`
+      }
+
+      const amountInBrandCurrency = Math.ceil(minimumUsd * rate.rate)
+      // Use 0 decimals for non-USD since we ceil to whole number
+      return `${symbol}${displayFiatAmount(amountInBrandCurrency, 0)}`
+    },
+    [fxRates, brand.currency]
+  )
+
   // Extract assets for wallet list modal and sync token map to ref
   // This ensures the ref is populated even when query returns cached data
   const allowedAssets = tokenQueryResult?.assets
@@ -337,7 +376,7 @@ export const GiftCardPurchaseScene: React.FC<Props> = props => {
         ),
         footer: sprintf(
           lstrings.gift_card_minimum_warning_footer,
-          `$${tokenInfo.minimumAmountInUSD.toFixed(2)} USD`
+          formatMinimumInBrandCurrency(tokenInfo.minimumAmountInUSD)
         )
       })
       return
@@ -537,7 +576,7 @@ export const GiftCardPurchaseScene: React.FC<Props> = props => {
           ),
           footer: sprintf(
             lstrings.gift_card_minimum_warning_footer,
-            `$${minimumUSD.toFixed(2)} USD`
+            formatMinimumInBrandCurrency(minimumUSD)
           )
         })
       } else {

src/plugins/gift-cards/phazeApi.ts

@@ -4,15 +4,25 @@ import { debugLog, maskHeaders } from '../../util/logger'
 import {
   asPhazeCreateOrderResponse,
   asPhazeError,
+  asPhazeFxRatesResponse,
   asPhazeGiftCardsResponse,
   asPhazeOrderStatusResponse,
   asPhazeRegisterUserResponse,
   asPhazeTokensResponse,
   type PhazeCreateOrderRequest,
+  type PhazeFxRate,
+  type PhazeGiftCardBrand,
   type PhazeOrderStatusResponse,
   type PhazeRegisterUserRequest
 } from './phazeGiftCardTypes'
 
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Minimum card value in USD. Cards below this are filtered out. */
+export const MINIMUM_CARD_VALUE_USD = 5
+
 // ---------------------------------------------------------------------------
 // Field definitions for different use cases
 // ---------------------------------------------------------------------------
@@ -71,6 +81,16 @@ export interface PhazeApi {
 
   // Endpoints:
   getTokens: () => Promise<ReturnType<typeof asPhazeTokensResponse>>
+  /**
+   * Ensures FX rates are fetched and cached.
+   * Called during provider initialization to guarantee rates are available.
+   */
+  ensureFxRates: () => Promise<void>
+  /**
+   * Returns cached FX rates. Guaranteed to be available after
+   * ensureFxRates() completes (called during provider init).
+   */
+  getCachedFxRates: () => PhazeFxRate[] | null
   getGiftCards: (params: {
     countryCode: string
     currentPage?: number
@@ -101,6 +121,7 @@ export interface PhazeApi {
 
 export const makePhazeApi = (config: PhazeApiConfig): PhazeApi => {
   let userApiKey = config.userApiKey
+  let cachedFxRates: PhazeFxRate[] | null = null
 
   const makeHeaders = (opts?: {
     includeUserKey?: boolean
@@ -179,6 +200,22 @@ export const makePhazeApi = (config: PhazeApiConfig): PhazeApi => {
     return response
   }
 
+  /** Fetch FX rates, using cached value if available */
+  const getOrFetchFxRates = async (): Promise<PhazeFxRate[]> => {
+    if (cachedFxRates != null) return cachedFxRates
+    const response = await fetchPhaze(buildUrl('/crypto/exchange-rates'), {
+      headers: makeHeaders()
+    })
+    const text = await response.text()
+    debugLog(
+      'phaze',
+      `getFxRates response: ${response.status} ${response.statusText}`
+    )
+    const parsed = asJSON(asPhazeFxRatesResponse)(text)
+    cachedFxRates = parsed.rates
+    return cachedFxRates
+  }
+
   return {
     setUserApiKey: (key?: string) => {
       userApiKey = key
@@ -199,34 +236,54 @@ export const makePhazeApi = (config: PhazeApiConfig): PhazeApi => {
       return asJSON(asPhazeTokensResponse)(text)
     },
 
+    ensureFxRates: async () => {
+      await getOrFetchFxRates()
+    },
+
+    getCachedFxRates: () => cachedFxRates,
+
     // GET /gift-cards/:country
     getGiftCards: async params => {
       const { countryCode, currentPage = 1, perPage = 50, brandName } = params
-      const response = await fetchPhaze(
-        buildUrl(`/gift-cards/${countryCode}`, {
-          currentPage,
-          perPage,
-          brandName
-        }),
-        {
-          headers: makeHeaders({ includePublicKey: true })
-        }
-      )
+      const [response, fxRates] = await Promise.all([
+        fetchPhaze(
+          buildUrl(`/gift-cards/${countryCode}`, {
+            currentPage,
+            perPage,
+            brandName
+          }),
+          {
+            headers: makeHeaders({ includePublicKey: true })
+          }
+        ),
+        getOrFetchFxRates()
+      ])
       const text = await response.text()
-      return asJSON(asPhazeGiftCardsResponse)(text)
+      const parsed = asJSON(asPhazeGiftCardsResponse)(text)
+      return {
+        ...parsed,
+        brands: filterBrandsByMinimum(parsed.brands, fxRates)
+      }
     },
 
     // GET /gift-cards/full/:country - Returns all brands without pagination
     getFullGiftCards: async params => {
       const { countryCode, fields, filter } = params
-      const response = await fetchPhaze(
-        buildUrl(`/gift-cards/full/${countryCode}`, { fields, filter }),
-        {
-          headers: makeHeaders({ includePublicKey: true })
-        }
-      )
+      const [response, fxRates] = await Promise.all([
+        fetchPhaze(
+          buildUrl(`/gift-cards/full/${countryCode}`, { fields, filter }),
+          {
+            headers: makeHeaders({ includePublicKey: true })
+          }
+        ),
+        getOrFetchFxRates()
+      ])
       const text = await response.text()
-      return asJSON(asPhazeGiftCardsResponse)(text)
+      const parsed = asJSON(asPhazeGiftCardsResponse)(text)
+      return {
+        ...parsed,
+        brands: filterBrandsByMinimum(parsed.brands, fxRates)
+      }
     },
 
     // GET /crypto/user?email=... - Lookup existing user by email
@@ -283,3 +340,101 @@ export const makePhazeApi = (config: PhazeApiConfig): PhazeApi => {
     }
   }
 }
+
+// ---------------------------------------------------------------------------
+// Brand Filtering Utilities
+// ---------------------------------------------------------------------------
+
+/**
+ * Convert USD amount to a local currency using FX rates.
+ * Rates are expected to be FROM USD TO the target currency.
+ * Rounds up to the next whole number to handle varying fiat precisions.
+ * Returns null if no rate is found for the currency.
+ */
+const convertFromUsd = (
+  amountUsd: number,
+  toCurrency: string,
+  fxRates: PhazeFxRate[]
+): number | null => {
+  if (toCurrency === 'USD') return amountUsd
+  const rate = fxRates.find(
+    r => r.fromCurrency === 'USD' && r.toCurrency === toCurrency
+  )
+  if (rate == null) return null
+  return Math.ceil(amountUsd * rate.rate)
+}
+
+/**
+ * Filter gift card brands to enforce minimum card value.
+ *
+ * - Fixed denomination cards: removes denominations below the minimum,
+ *   and removes the brand entirely if no denominations remain.
+ * - Variable amount cards: caps minVal to the minimum if below,
+ *   and removes the brand if maxVal is below the minimum.
+ *
+ * @param brands - Array of gift card brands to filter
+ * @param fxRates - FX rates from USD to other currencies
+ * @param minimumUsd - Minimum card value in USD (defaults to MINIMUM_CARD_VALUE_USD)
+ * @returns Filtered array of brands with valid denominations/restrictions
+ */
+export const filterBrandsByMinimum = (
+  brands: PhazeGiftCardBrand[],
+  fxRates: PhazeFxRate[],
+  minimumUsd: number = MINIMUM_CARD_VALUE_USD
+): PhazeGiftCardBrand[] => {
+  return brands
+    .map(brand => {
+      const { currency, denominations, valueRestrictions } = brand
+
+      // Convert minimum USD to brand's currency
+      const minInBrandCurrency = convertFromUsd(minimumUsd, currency, fxRates)
+
+      // If we can't convert, just return the brand as-is
+      if (minInBrandCurrency == null) return brand
+
+      // Variable amount card (has minVal/maxVal restrictions)
+      if (valueRestrictions.maxVal != null) {
+        // Exclude brand if maxVal is below minimum
+        if (valueRestrictions.maxVal < minInBrandCurrency) {
+          return null
+        }
+
+        // Cap minVal to our minimum if it's below
+        const cappedMinVal =
+          valueRestrictions.minVal != null &&
+          valueRestrictions.minVal < minInBrandCurrency
+            ? minInBrandCurrency
+            : valueRestrictions.minVal
+
+        return {
+          ...brand,
+          valueRestrictions: {
+            ...valueRestrictions,
+            minVal: cappedMinVal
+          }
+        }
+      }
+
+      // Fixed denomination card
+      if (denominations.length > 0) {
+        const filteredDenoms = denominations.filter(
+          denom => denom >= minInBrandCurrency
+        )
+
+        // No valid denominations remain, exclude the brand
+        if (filteredDenoms.length === 0) {
+          return null
+        }
+
+        // Return brand with filtered denominations
+        return {
+          ...brand,
+          denominations: filteredDenoms
+        }
+      }
+
+      // No denominations and no value restrictions - exclude
+      return null
+    })
+    .filter((brand): brand is PhazeGiftCardBrand => brand != null)
+}

src/plugins/gift-cards/phazeGiftCardProvider.ts

@@ -17,6 +17,7 @@ import { saveOrderAugment } from './phazeGiftCardOrderStore'
 import {
   cleanBrandName,
   type PhazeCreateOrderRequest,
+  type PhazeFxRate,
   type PhazeGiftCardBrand,
   type PhazeGiftCardsResponse,
   type PhazeOrderStatusResponse,
@@ -90,6 +91,11 @@ export interface PhazeGiftCardProvider {
   getCache: () => PhazeGiftCardCache
 
   getTokens: () => Promise<PhazeTokensResponse>
+  /**
+   * Returns cached FX rates. Rates are automatically fetched and cached
+   * when calling getMarketBrands or other brand-fetching methods.
+   */
+  getCachedFxRates: () => PhazeFxRate[] | null
 
   // ---------------------------------------------------------------------------
   // Brand fetching - smart methods
@@ -265,6 +271,12 @@ export const makePhazeGiftCardProvider = (
         return false
       }
 
+      // Pre-fetch FX rates so they're available for brand filtering and
+      // minimum amount display. This runs in parallel with identity loading.
+      const fxRatesPromise = api.ensureFxRates().catch((err: unknown) => {
+        debugLog('phaze', 'Failed to pre-fetch FX rates:', err)
+      })
+
       // Check for existing identities. Uses the first identity found for purchases/orders.
       // Multiple identities is an edge case (multi-device before sync completes) -
       // new orders simply go to whichever identity is active.
@@ -275,6 +287,7 @@ export const makePhazeGiftCardProvider = (
         if (identity.userApiKey != null) {
           api.setUserApiKey(identity.userApiKey)
           debugLog('phaze', 'Using existing identity:', identity.uniqueId)
+          await fxRatesPromise
           return true
         }
       }
@@ -313,6 +326,7 @@ export const makePhazeGiftCardProvider = (
 
         api.setUserApiKey(userApiKey)
         debugLog('phaze', 'Auto-registered and saved identity:', uniqueId)
+        await fxRatesPromise
         return true
       } catch (err: unknown) {
         debugLog('phaze', 'Auto-registration failed:', err)
@@ -331,6 +345,10 @@ export const makePhazeGiftCardProvider = (
       return await api.getTokens()
     },
 
+    getCachedFxRates: () => {
+      return api.getCachedFxRates()
+    },
+
     // ---------------------------------------------------------------------------
     // Brand fetching - smart methods
     // ---------------------------------------------------------------------------