0xtrails 0.12.0 → 0.12.2

package/src/widget/hooks/useExchangeRate.ts

@@ -1,257 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import { useEffect } from "react"
-import { useTrailsClient } from "../../trailsClient.js"
-import { useDisplayCurrencyPreference } from "./useDisplayCurrencyPreference.js"
-import { MINUTE_MS, HOUR_MS } from "../../utils/time.js"
-
-interface UseExchangeRateOptions {
-  fromCurrency?: string
-  toCurrency?: string
-  disabled?: boolean
-}
-
-interface UseExchangeRateResult {
-  exchangeRate: number | undefined
-  isLoading: boolean
-  error: Error | null
-}
-
-interface ExchangeRateCache {
-  value: number
-  name: string
-  symbol: string
-  vsCurrency: string
-  currencyType: string
-  timestamp: number
-}
-
-const EXCHANGE_RATE_CACHE_KEY_PREFIX = "trails-exchange-rate-"
-const EXCHANGE_RATE_CACHE_DURATION = HOUR_MS // 1 hour in milliseconds
-
-/**
- * Get cached exchange rate from localStorage
- */
-function getCachedExchangeRate(currency: string): ExchangeRateCache | null {
-  try {
-    const key = `${EXCHANGE_RATE_CACHE_KEY_PREFIX}${currency.toUpperCase()}`
-    const cached = localStorage.getItem(key)
-    if (!cached) return null
-
-    const data = JSON.parse(cached) as ExchangeRateCache
-    const now = Date.now()
-
-    // Check if cache is expired (older than 1 hour)
-    if (now - data.timestamp > EXCHANGE_RATE_CACHE_DURATION) {
-      localStorage.removeItem(key)
-      return null
-    }
-
-    return data
-  } catch (error) {
-    console.warn("Failed to get cached exchange rate:", error)
-    return null
-  }
-}
-
-/**
- * Save exchange rate to localStorage cache
- */
-function setCachedExchangeRate(
-  currency: string,
-  data: {
-    value: number
-    name: string
-    symbol: string
-    vsCurrency: string
-    currencyType: string
-  },
-): void {
-  try {
-    const key = `${EXCHANGE_RATE_CACHE_KEY_PREFIX}${currency.toUpperCase()}`
-    const cacheData: ExchangeRateCache = {
-      ...data,
-      timestamp: Date.now(),
-    }
-    localStorage.setItem(key, JSON.stringify(cacheData))
-  } catch (error) {
-    console.warn("Failed to cache exchange rate:", error)
-  }
-}
-
-/**
- * Wrapper hook for exchange rate fetching that abstracts the underlying implementation
- * This allows us to easily swap out the exchange rate provider in the future
- */
-export function useExchangeRate(
-  options: UseExchangeRateOptions = {},
-): UseExchangeRateResult {
-  const { fromCurrency = "USD", toCurrency = "USD", disabled = false } = options
-
-  const trailsClient = useTrailsClient()
-
-  // Handle same currency case
-  const isSameCurrency = fromCurrency === toCurrency
-
-  // Determine which currency to fetch
-  const targetCurrency = fromCurrency === "USD" ? toCurrency : fromCurrency
-
-  const { data, isLoading, error } = useQuery({
-    queryKey: ["exchangeRate", targetCurrency],
-    queryFn: async () => {
-      // Same currency, no API call needed
-      if (isSameCurrency) {
-        return { value: 1 }
-      }
-
-      // Check localStorage cache first
-      const cached = getCachedExchangeRate(targetCurrency)
-      if (cached) {
-        return cached
-      }
-
-      // Fetch from API if not cached
-      const response = await trailsClient.getExchangeRate({
-        toCurrency: targetCurrency,
-      })
-
-      // Cache the response
-      if (response.exchangeRate) {
-        setCachedExchangeRate(targetCurrency, response.exchangeRate)
-      }
-
-      return response.exchangeRate
-    },
-    enabled: !disabled && !isSameCurrency,
-    staleTime: 5 * MINUTE_MS, // Consider React Query cache stale after 5 minutes
-    gcTime: HOUR_MS, // Keep in React Query cache for 1 hour
-  })
-
-  // Also update localStorage when data changes from other sources
-  useEffect(() => {
-    if (
-      data &&
-      !isSameCurrency &&
-      data.value &&
-      "name" in data &&
-      "symbol" in data &&
-      "vsCurrency" in data &&
-      "currencyType" in data
-    ) {
-      setCachedExchangeRate(targetCurrency, data)
-    }
-  }, [data, isSameCurrency, targetCurrency])
-
-  // Calculate the exchange rate based on the conversion direction
-  let exchangeRate: number | undefined
-
-  if (isSameCurrency) {
-    exchangeRate = 1
-  } else if (data?.value) {
-    if (fromCurrency === "USD" && toCurrency !== "USD") {
-      // USD to another currency - use the rate directly
-      exchangeRate = data.value
-    } else if (fromCurrency !== "USD" && toCurrency === "USD") {
-      // Currency to USD - invert the rate
-      exchangeRate = 1 / data.value
-    }
-  }
-
-  return {
-    exchangeRate,
-    isLoading,
-    error: error as Error | null,
-  }
-}
-
-/**
- * Hook to get exchange rate from USD to user's preferred display currency
- */
-export function useUsdToDisplayCurrencyRate(): UseExchangeRateResult {
-  const { getEffectiveCurrency } = useDisplayCurrencyPreference()
-  const displayCurrency = getEffectiveCurrency()
-
-  return useExchangeRate({
-    fromCurrency: "USD",
-    toCurrency: displayCurrency,
-    disabled: displayCurrency === "USD",
-  })
-}
-
-/**
- * Hook to convert USD amount to user's preferred display currency
- */
-export function useConvertUsdToDisplayCurrency(): {
-  convert: (usdAmount: number) => number
-  formatAmount: (usdAmount: number) => string
-  displayCurrency: string
-  exchangeRate: number | undefined
-  isLoading: boolean
-} {
-  const { getEffectiveCurrency } = useDisplayCurrencyPreference()
-  const displayCurrency = getEffectiveCurrency()
-  const { exchangeRate, isLoading } = useUsdToDisplayCurrencyRate()
-
-  const convert = (usdAmount: number): number => {
-    if (displayCurrency === "USD" || !exchangeRate) {
-      return usdAmount
-    }
-    return usdAmount * exchangeRate
-  }
-
-  const formatAmount = (usdAmount: number): string => {
-    const convertedAmount = convert(usdAmount)
-
-    // Get currency info for proper formatting
-    const currencyInfo = getCurrencyInfo(displayCurrency)
-
-    return new Intl.NumberFormat("en-US", {
-      style: "currency",
-      currency: displayCurrency,
-      minimumFractionDigits: currencyInfo.decimals,
-      maximumFractionDigits: currencyInfo.decimals,
-    }).format(convertedAmount)
-  }
-
-  return {
-    convert,
-    formatAmount,
-    displayCurrency,
-    exchangeRate,
-    isLoading,
-  }
-}
-
-// Helper to get currency info
-function getCurrencyInfo(currencyCode: string): {
-  decimals: number
-  symbol: string
-} {
-  // Currencies with 0 decimals
-  const zeroDecimalCurrencies = ["JPY", "KRW", "VND", "CLP", "ISK"]
-
-  // Default to 2 decimals for most currencies
-  const decimals = zeroDecimalCurrencies.includes(currencyCode) ? 0 : 2
-
-  // Currency symbols mapping
-  const symbols: Record<string, string> = {
-    USD: "$",
-    EUR: "€",
-    GBP: "£",
-    JPY: "¥",
-    CNY: "¥",
-    KRW: "₩",
-    INR: "₹",
-    CAD: "C$",
-    AUD: "A$",
-    CHF: "CHF",
-    SEK: "kr",
-    NOK: "kr",
-    DKK: "kr",
-    // Add more as needed
-  }
-
-  return {
-    decimals,
-    symbol: symbols[currencyCode] || currencyCode,
-  }
-}

package/src/widget/hooks/useFiatCurrencyList.ts

@@ -1,66 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import { queryPersister } from "../../query/persister.js"
-import { useTrailsClient } from "../../trailsClient.js"
-import { DAY_MS } from "../../utils/time.js"
-import type { FiatCurrency } from "@0xtrails/api"
-
-const CURRENCY_LIST_CACHE_KEY = "0xtrails_fiat_currencies"
-const CURRENCY_LIST_CACHE_DURATION = DAY_MS // 24 hours
-
-interface CachedCurrencyData {
-  currencies: FiatCurrency[]
-  timestamp: number
-}
-
-function getCachedCurrencyList(): FiatCurrency[] | null {
-  try {
-    const cached = localStorage.getItem(CURRENCY_LIST_CACHE_KEY)
-    if (!cached) return null
-
-    const data: CachedCurrencyData = JSON.parse(cached)
-    const now = Date.now()
-
-    if (now - data.timestamp > CURRENCY_LIST_CACHE_DURATION) {
-      localStorage.removeItem(CURRENCY_LIST_CACHE_KEY)
-      return null
-    }
-
-    return data.currencies
-  } catch {
-    return null
-  }
-}
-
-function setCachedCurrencyList(currencies: FiatCurrency[]): void {
-  try {
-    const data: CachedCurrencyData = {
-      currencies,
-      timestamp: Date.now(),
-    }
-    localStorage.setItem(CURRENCY_LIST_CACHE_KEY, JSON.stringify(data))
-  } catch {
-    // Ignore localStorage errors
-  }
-}
-
-export function useFiatCurrencyList() {
-  const trailsClient = useTrailsClient()
-
-  return useQuery({
-    queryKey: ["fiatCurrencyList"],
-    queryFn: async () => {
-      const cached = getCachedCurrencyList()
-      if (cached) {
-        return cached
-      }
-
-      const response = await trailsClient.getFiatCurrencyList()
-      const currencies = response.currencies || []
-      setCachedCurrencyList(currencies)
-      return currencies
-    },
-    staleTime: CURRENCY_LIST_CACHE_DURATION,
-    gcTime: CURRENCY_LIST_CACHE_DURATION,
-    persister: queryPersister.persisterFn,
-  })
-}