@b3dotfun/sdk 0.0.58-alpha.1 → 0.0.58-alpha.2

package/src/shared/react/hooks/useCurrencyConversion.ts

@@ -1,6 +1,6 @@
 import { useQuery } from "@tanstack/react-query";
 import { formatDisplayNumber } from "@b3dotfun/sdk/shared/utils/number";
-import { CURRENCY_SYMBOLS, useCurrencyStore } from "../stores/currencyStore";
+import { useCurrencyStore, getCurrencySymbol, getCurrencyMetadata } from "../stores/currencyStore";
 
 const COINBASE_API_URL = "https://api.coinbase.com/v2/exchange-rates";
 const REFETCH_INTERVAL_MS = 30000;
@@ -47,9 +47,11 @@ async function fetchAllExchangeRates(baseCurrency: string): Promise<Record<strin
 export function useCurrencyConversion() {
   const selectedCurrency = useCurrencyStore(state => state.selectedCurrency);
   const baseCurrency = useCurrencyStore(state => state.baseCurrency);
+  const getCustomExchangeRate = useCurrencyStore(state => state.getExchangeRate);
+  const customCurrencies = useCurrencyStore(state => state.customCurrencies);
 
-  // Fetch all exchange rates for the base currency
-  const { data: exchangeRates } = useQuery({
+  // Fetch all exchange rates for the base currency from Coinbase API
+  const { data: apiExchangeRates } = useQuery({
     queryKey: ["exchangeRates", baseCurrency],
     queryFn: () => fetchAllExchangeRates(baseCurrency),
     refetchInterval: REFETCH_INTERVAL_MS,
@@ -58,93 +60,163 @@ export function useCurrencyConversion() {
     retryDelay: attemptIndex => Math.min(1000 * 2 ** attemptIndex, REFETCH_INTERVAL_MS),
   });
 
-  // Extract specific rates from the full rates object
-  const exchangeRate = exchangeRates?.[selectedCurrency];
-  const usdRate = exchangeRates?.["USD"];
+  /**
+   * Get exchange rate between two currencies, checking custom rates first, then API rates.
+   * Supports chaining through base currency for custom currencies.
+   *
+   * Examples:
+   * - WIN → USD: Checks WIN→USD custom rate, then chains WIN→B3→USD
+   * - BTC → EUR: Checks BTC→EUR custom rate, then chains BTC→B3→EUR
+   */
+  const getExchangeRate = (from: string, to: string): number | undefined => {
+    // If same currency, rate is 1
+    if (from === to) return 1;
+
+    // 1. Check direct custom exchange rate first
+    const directCustomRate = getCustomExchangeRate(from, to);
+    if (directCustomRate !== undefined) {
+      return directCustomRate;
+    }
+
+    // 2. Check direct API rate (from base currency)
+    if (from === baseCurrency && apiExchangeRates) {
+      return apiExchangeRates[to];
+    }
+
+    // 3. Try to chain through base currency using custom rates
+    // e.g., WIN → B3 → USD (where WIN→B3 is custom, B3→USD is API)
+    const customFromToBase = getCustomExchangeRate(from, baseCurrency);
+    if (customFromToBase !== undefined) {
+      // We have a custom rate from 'from' to base
+      // Now get rate from base to 'to'
+      const baseToTo = apiExchangeRates?.[to] ?? getCustomExchangeRate(baseCurrency, to);
+      if (baseToTo !== undefined) {
+        return customFromToBase * baseToTo;
+      }
+    }
+
+    // 4. Try reverse: chain from base currency through custom rate
+    // e.g., USD → B3 → WIN (where B3→WIN is custom)
+    const customBaseToTo = getCustomExchangeRate(baseCurrency, to);
+    if (customBaseToTo !== undefined && apiExchangeRates) {
+      // We have a custom rate from base to 'to'
+      // Now get rate from 'from' to base
+      const fromToBase = apiExchangeRates[from];
+      if (fromToBase !== undefined && fromToBase !== 0) {
+        return fromToBase * customBaseToTo;
+      }
+    }
+
+    // 5. Fall back to pure API conversion through base
+    // e.g., EUR to GBP = (EUR to B3) * (B3 to GBP)
+    if (apiExchangeRates) {
+      const fromToBase = apiExchangeRates[from];
+      const baseToTo = apiExchangeRates[to];
+      if (fromToBase && baseToTo && fromToBase !== 0) {
+        return baseToTo / fromToBase;
+      }
+    }
+
+    return undefined;
+  };
+
+  // Extract specific rates
+  const exchangeRate = getExchangeRate(baseCurrency, selectedCurrency);
 
   /**
-   * Formats a numeric value as a currency string with proper conversion and formatting.
+   * Formats a numeric value as a currency string with automatic conversion.
    *
-   * Behavior:
-   * - When exchange rate is unavailable, displays value in base currency
-   * - Applies currency-specific formatting rules:
-   *   - JPY/KRW: No decimal places
-   *   - ETH/SOL: 6 significant digits with subscript notation for small values
-   *   - Fiat (USD/EUR/GBP/CAD/AUD): 2 decimal places minimum for values < 1000
-   * - Handles symbol positioning (prefix for fiat, suffix for crypto)
+   * New behavior:
+   * - Takes the SOURCE currency (what the value is in) as a required parameter
+   * - Automatically converts from source → display currency (selected in picker)
+   * - Supports multi-hop conversions (e.g., WIN → B3 → USD)
+   * - Applies currency-specific formatting rules to the TARGET currency
    *
-   * @param value - The numeric value to format (in base currency)
+   * @param value - The numeric value to format
+   * @param sourceCurrency - The currency the value is currently in (e.g., "WIN", "B3", "USD")
    * @param options - Optional formatting overrides
-   * @param options.decimals - Override number of decimal places
-   * @param options.currency - Override currency (bypasses conversion)
+   * @param options.decimals - Override number of decimal places for display
    * @returns Formatted currency string with appropriate symbol and decimal places
    *
    * @example
    * ```tsx
-   * formatCurrencyValue(100) // Returns "$100.00" if USD is selected
-   * formatCurrencyValue(0.0001) // Returns "0.0₄1 ETH" if ETH is selected
-   * formatCurrencyValue(1500) // Returns "¥1,500" if JPY is selected
-   * formatCurrencyValue(100, { decimals: 4, currency: "ETH" }) // Returns "100.0000 ETH"
+   * // Value is 3031 WIN, user has USD selected
+   * formatCurrencyValue(3031, "WIN") // Returns "$30.31" (converts WIN→B3→USD)
+   *
+   * // Value is 100 B3, user has B3 selected (no conversion)
+   * formatCurrencyValue(100, "B3") // Returns "100 B3"
+   *
+   * // Value is 50 USD, user has EUR selected
+   * formatCurrencyValue(50, "USD") // Returns "€45.50" (converts USD→EUR)
    * ```
    */
-  const formatCurrencyValue = (value: number, options?: { decimals?: number; currency?: string }): string => {
-    const overrideCurrency = options?.currency;
+  const formatCurrencyValue = (value: number, sourceCurrency: string, options?: { decimals?: number }): string => {
     const overrideDecimals = options?.decimals;
 
-    // Custom currency provided - bypass conversion and use simple formatting
-    if (overrideCurrency) {
-      const decimalsToUse = overrideDecimals !== undefined ? overrideDecimals : overrideCurrency === "B3" ? 0 : 2;
+    // If source and display currency are the same, no conversion needed
+    if (sourceCurrency === selectedCurrency) {
+      const customMetadata = getCurrencyMetadata(sourceCurrency);
+      const decimalsToUse = overrideDecimals !== undefined ? overrideDecimals : customMetadata?.decimals;
 
       const formatted = formatDisplayNumber(value, {
         fractionDigits: decimalsToUse,
-        showSubscripts: false,
+        significantDigits: decimalsToUse === undefined ? 6 : undefined,
+        showSubscripts: customMetadata?.showSubscripts ?? false,
       });
-      return `${formatted} ${overrideCurrency}`;
-    }
 
-    // Custom decimals for base currency without conversion
-    if (overrideDecimals !== undefined && selectedCurrency === baseCurrency) {
-      const formatted = formatDisplayNumber(value, {
-        fractionDigits: overrideDecimals,
-        showSubscripts: false,
-      });
-      return `${formatted} ${baseCurrency}`;
+      const symbol = getCurrencySymbol(sourceCurrency);
+      const usePrefix = customMetadata?.prefixSymbol ?? ["USD", "EUR", "GBP", "CAD", "AUD"].includes(sourceCurrency);
+
+      return usePrefix ? `${symbol}${formatted}` : `${formatted} ${symbol}`;
     }
 
-    // If showing base currency, no conversion needed
-    if (selectedCurrency === baseCurrency || !exchangeRate) {
+    // Get exchange rate from source to display currency
+    const conversionRate = getExchangeRate(sourceCurrency, selectedCurrency);
+
+    // If no conversion rate available, display in source currency
+    if (conversionRate === undefined) {
+      const customMetadata = getCurrencyMetadata(sourceCurrency);
       const formatted = formatDisplayNumber(value, {
-        significantDigits: baseCurrency === "B3" ? 6 : 8,
-        showSubscripts: true,
+        significantDigits: 6,
+        showSubscripts: customMetadata?.showSubscripts ?? false,
       });
-      return `${formatted} ${baseCurrency}`;
+      const symbol = getCurrencySymbol(sourceCurrency);
+      return `${formatted} ${symbol}`;
     }
 
-    // Convert value using current exchange rate
-    const convertedValue = value * exchangeRate;
-    const symbol = CURRENCY_SYMBOLS[selectedCurrency];
+    // Convert value
+    const convertedValue = value * conversionRate;
 
-    // Currencies that display symbol before the number (e.g., $100.00)
-    const prefixCurrencies = ["USD", "EUR", "GBP", "CAD", "AUD"];
+    // Get symbol and metadata for display currency
+    const symbol = getCurrencySymbol(selectedCurrency);
+    const customMetadata = getCurrencyMetadata(selectedCurrency);
+    const usePrefix = customMetadata?.prefixSymbol ?? ["USD", "EUR", "GBP", "CAD", "AUD"].includes(selectedCurrency);
 
     let formatted: string;
 
-    if (selectedCurrency === "JPY" || selectedCurrency === "KRW") {
-      // Japanese Yen and Korean Won don't use decimal places
+    // Apply formatting based on display currency
+    if (overrideDecimals !== undefined) {
+      formatted = formatDisplayNumber(convertedValue, {
+        fractionDigits: overrideDecimals,
+        showSubscripts: false,
+      });
+    } else if (customMetadata) {
+      formatted = formatDisplayNumber(convertedValue, {
+        fractionDigits: customMetadata.decimals,
+        significantDigits: customMetadata.decimals === undefined ? 6 : undefined,
+        showSubscripts: customMetadata.showSubscripts ?? false,
+      });
+    } else if (selectedCurrency === "JPY" || selectedCurrency === "KRW") {
       formatted = formatDisplayNumber(convertedValue, {
         fractionDigits: 0,
         showSubscripts: false,
       });
     } else if (selectedCurrency === "ETH" || selectedCurrency === "SOL") {
-      // Crypto currencies use more precision and subscript notation
-      // for very small amounts (e.g., 0.0₃45 ETH)
       formatted = formatDisplayNumber(convertedValue, {
         significantDigits: 6,
         showSubscripts: true,
       });
     } else {
-      // Standard fiat currencies (USD, EUR, GBP, CAD, AUD)
-      // Use 2 decimal places minimum for amounts under 1000
       formatted = formatDisplayNumber(convertedValue, {
         significantDigits: 6,
         fractionDigits: convertedValue < 1000 ? 2 : undefined,
@@ -152,71 +224,62 @@ export function useCurrencyConversion() {
       });
     }
 
-    // Apply currency symbol with correct positioning
-    if (prefixCurrencies.includes(selectedCurrency)) {
-      return `${symbol}${formatted}`;
-    } else {
-      // Suffix currencies: JPY, KRW, ETH, SOL, B3
-      return `${formatted} ${symbol}`;
-    }
+    return usePrefix ? `${symbol}${formatted}` : `${formatted} ${symbol}`;
   };
 
   /**
    * Formats a tooltip value showing the alternate currency representation.
    *
-   * Behavior:
-   * - When displaying base currency: Shows USD equivalent
-   * - When displaying other currency: Shows base currency equivalent
-   * - For custom currencies: Shows appropriate conversion or original value
+   * New behavior:
+   * - Takes the SOURCE currency (what the value is in)
+   * - When displaying in non-USD: Shows USD equivalent in tooltip
+   * - When displaying in USD: Shows source currency in tooltip
    *
    * @param value - The numeric value to format
-   * @param customCurrency - Optional custom currency override
+   * @param sourceCurrency - The currency the value is currently in
    * @returns Formatted tooltip string
    *
    * @example
    * ```tsx
-   * formatTooltipValue(100) // Returns "$150.00 USD" if displaying B3 with rate 1.5
-   * formatTooltipValue(100, "ETH") // Returns "100.0000 ETH" if custom currency
+   * // Value is 3031 WIN, displaying as EUR
+   * formatTooltipValue(3031, "WIN") // Returns "$30.31 USD"
+   *
+   * // Value is 100 B3, displaying as USD
+   * formatTooltipValue(100, "B3") // Returns "100 B3"
    * ```
    */
-  const formatTooltipValue = (value: number, customCurrency?: string): string => {
-    const displayCurrency = customCurrency || selectedCurrency;
+  const formatTooltipValue = (value: number, sourceCurrency: string): string => {
     const absoluteValue = Math.abs(value);
 
-    // Custom currency provided
-    if (customCurrency) {
-      if (customCurrency === baseCurrency) {
-        // Show USD equivalent for base currency using USD rate
-        const usdValue = usdRate ? absoluteValue * usdRate : absoluteValue;
-        const formatted = formatDisplayNumber(usdValue, {
-          significantDigits: 6,
-          fractionDigits: usdValue < 1000 ? 2 : undefined,
-          showSubscripts: true,
-        });
-        return `$${formatted} USD`;
-      } else {
-        // Show as-is for other custom currencies
-        return `${formatDisplayNumber(absoluteValue, { significantDigits: 6 })} ${customCurrency}`;
-      }
+    // If displaying in USD, show source currency in tooltip
+    if (selectedCurrency === "USD") {
+      const formatted = formatDisplayNumber(absoluteValue, {
+        significantDigits: 6,
+        showSubscripts: getCurrencyMetadata(sourceCurrency)?.showSubscripts ?? false,
+      });
+      const symbol = getCurrencySymbol(sourceCurrency);
+      return `${formatted} ${symbol}`;
     }
 
-    // Showing base currency - display USD equivalent
-    if (displayCurrency === baseCurrency) {
-      const usdValue = usdRate ? absoluteValue * usdRate : absoluteValue;
-      const formatted = formatDisplayNumber(usdValue, {
+    // Otherwise, show USD equivalent in tooltip
+    const usdRate = getExchangeRate(sourceCurrency, "USD");
+    if (usdRate === undefined) {
+      // Fallback to source currency if no USD rate
+      const formatted = formatDisplayNumber(absoluteValue, {
         significantDigits: 6,
-        fractionDigits: usdValue < 1000 ? 2 : undefined,
-        showSubscripts: true,
+        showSubscripts: getCurrencyMetadata(sourceCurrency)?.showSubscripts ?? false,
       });
-      return `$${formatted} USD`;
+      const symbol = getCurrencySymbol(sourceCurrency);
+      return `${formatted} ${symbol}`;
     }
 
-    // Showing other currency - display base currency equivalent
-    const formatted = formatDisplayNumber(absoluteValue, {
-      significantDigits: baseCurrency === "B3" ? 6 : 8,
+    const usdValue = absoluteValue * usdRate;
+    const formatted = formatDisplayNumber(usdValue, {
+      significantDigits: 6,
+      fractionDigits: usdValue < 1000 ? 2 : undefined,
       showSubscripts: true,
     });
-    return `${formatted} ${baseCurrency}`;
+    return `$${formatted} USD`;
   };
 
   return {
@@ -231,8 +294,12 @@ export function useCurrencyConversion() {
     /** Format a tooltip value showing alternate currency representation */
     formatTooltipValue,
     /** Symbol for the currently selected currency (e.g., "$", "€", "ETH") */
-    selectedCurrencySymbol: CURRENCY_SYMBOLS[selectedCurrency],
+    selectedCurrencySymbol: getCurrencySymbol(selectedCurrency),
     /** Symbol for the base currency */
-    baseCurrencySymbol: CURRENCY_SYMBOLS[baseCurrency],
+    baseCurrencySymbol: getCurrencySymbol(baseCurrency),
+    /** Get exchange rate between any two currencies */
+    getExchangeRate,
+    /** All registered custom currencies */
+    customCurrencies,
   };
 }

package/src/shared/react/stores/currencyStore.ts

@@ -2,11 +2,41 @@ import { create } from "zustand";
 import { persist } from "zustand/middleware";
 
 /**
- * Supported currencies for display and conversion.
+ * Built-in supported currencies for display and conversion.
  * Includes fiat currencies (USD, EUR, GBP, JPY, CAD, AUD, KRW) and crypto (ETH, SOL, B3).
  */
 export type SupportedCurrency = "ETH" | "USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD" | "B3" | "SOL" | "KRW";
 
+/**
+ * Metadata for a custom currency including display formatting rules.
+ */
+export interface CurrencyMetadata {
+  /** The currency code/symbol (e.g., "BTC", "DOGE") */
+  code: string;
+  /** Display symbol for the currency (e.g., "₿", "Ð") */
+  symbol: string;
+  /** Human-readable name (e.g., "Bitcoin", "Dogecoin") */
+  name: string;
+  /** Whether to show symbol before the value (true for $100, false for 100 ETH) */
+  prefixSymbol?: boolean;
+  /** Number of decimal places to show (undefined uses smart formatting) */
+  decimals?: number;
+  /** Whether to use subscript notation for small values */
+  showSubscripts?: boolean;
+}
+
+/**
+ * Exchange rate between two currencies.
+ */
+export interface ExchangeRate {
+  /** Currency code being converted from */
+  from: string;
+  /** Currency code being converted to */
+  to: string;
+  /** Exchange rate multiplier (amount_in_to = amount_in_from * rate) */
+  rate: number;
+}
+
 /**
  * Currency symbols used for display formatting.
  * Prefix currencies (USD, EUR, GBP, CAD, AUD) show symbol before the amount.
@@ -45,38 +75,214 @@ export const CURRENCY_NAMES: Record<SupportedCurrency, string> = {
  * Currency store state interface.
  * @property selectedCurrency - The currency currently selected for display
  * @property baseCurrency - The base currency for conversion (typically B3)
+ * @property customCurrencies - Map of custom currency codes to their metadata
+ * @property customExchangeRates - Map of "FROM-TO" pairs to exchange rates
  * @property setSelectedCurrency - Update the selected display currency
  * @property setBaseCurrency - Update the base currency for conversions
+ * @property addCurrency - Register a new custom currency with metadata
+ * @property removeCurrency - Remove a custom currency
+ * @property setExchangeRate - Set a custom exchange rate between two currencies
+ * @property getExchangeRate - Get exchange rate between two currencies
+ * @property getAllCurrencies - Get all available currencies (built-in + custom)
  */
 interface CurrencyState {
-  selectedCurrency: SupportedCurrency;
-  baseCurrency: SupportedCurrency;
-  setSelectedCurrency: (currency: SupportedCurrency) => void;
-  setBaseCurrency: (currency: SupportedCurrency) => void;
+  selectedCurrency: string;
+  baseCurrency: string;
+  customCurrencies: Record<string, CurrencyMetadata>;
+  customExchangeRates: Record<string, number>;
+  setSelectedCurrency: (currency: string) => void;
+  setBaseCurrency: (currency: string) => void;
+  addCurrency: (metadata: CurrencyMetadata) => void;
+  removeCurrency: (code: string) => void;
+  setExchangeRate: (from: string, to: string, rate: number) => void;
+  getExchangeRate: (from: string, to: string) => number | undefined;
+  getAllCurrencies: () => string[];
 }
 
 /**
  * Zustand store for managing currency selection and conversion.
  * Persists user's selected currency preference in localStorage.
+ * Supports dynamic currency registration and custom exchange rates.
  *
  * @example
  * ```tsx
- * const { selectedCurrency, setSelectedCurrency } = useCurrencyStore();
- * // Change display currency to USD
- * setSelectedCurrency('USD');
+ * const { selectedCurrency, setSelectedCurrency, addCurrency, setExchangeRate } = useCurrencyStore();
+ *
+ * // Add a new currency
+ * addCurrency({
+ *   code: "BTC",
+ *   symbol: "₿",
+ *   name: "Bitcoin",
+ *   showSubscripts: true,
+ * });
+ *
+ * // Set exchange rate: 1 BTC = 50000 USD
+ * setExchangeRate("BTC", "USD", 50000);
+ *
+ * // Change display currency
+ * setSelectedCurrency('BTC');
  * ```
  */
 export const useCurrencyStore = create<CurrencyState>()(
   persist(
-    set => ({
+    (set, get) => ({
       selectedCurrency: "B3",
       baseCurrency: "B3",
+      customCurrencies: {},
+      customExchangeRates: {},
+
       setSelectedCurrency: currency => set({ selectedCurrency: currency }),
+
       setBaseCurrency: currency => set({ baseCurrency: currency }),
+
+      addCurrency: metadata => {
+        set(state => ({
+          customCurrencies: {
+            ...state.customCurrencies,
+            [metadata.code]: metadata,
+          },
+        }));
+      },
+
+      removeCurrency: code => {
+        set(state => {
+          // Remove the currency
+          const { [code]: _removed, ...remaining } = state.customCurrencies;
+
+          // Remove all exchange rates involving this currency
+          const filteredRates: Record<string, number> = {};
+          for (const [key, rate] of Object.entries(state.customExchangeRates)) {
+            // Key format is "FROM-TO", skip if either matches the removed code
+            const [from, to] = key.split("-");
+            if (from !== code && to !== code) {
+              filteredRates[key] = rate;
+            }
+          }
+
+          return {
+            customCurrencies: remaining,
+            customExchangeRates: filteredRates,
+          };
+        });
+      },
+
+      setExchangeRate: (from, to, rate) => {
+        set(state => {
+          const key = `${from}-${to}`;
+          const inverseKey = `${to}-${from}`;
+
+          // Only set inverse rate if rate is not 0 (to avoid Infinity)
+          const newRates: Record<string, number> = {
+            ...state.customExchangeRates,
+            [key]: rate,
+          };
+
+          if (rate !== 0) {
+            newRates[inverseKey] = 1 / rate;
+          }
+
+          return {
+            customExchangeRates: newRates,
+          };
+        });
+      },
+
+      getExchangeRate: (from, to) => {
+        const key = `${from}-${to}`;
+        return get().customExchangeRates[key];
+      },
+
+      getAllCurrencies: () => {
+        const builtIn = Object.keys(CURRENCY_SYMBOLS);
+        const custom = Object.keys(get().customCurrencies);
+        return [...builtIn, ...custom];
+      },
     }),
     {
       name: "currency-storage",
-      version: 2,
+      version: 3,
     },
   ),
 );
+
+/**
+ * Get the symbol for any currency (built-in or custom).
+ */
+export function getCurrencySymbol(currency: string): string {
+  // Check built-in currencies first
+  if (currency in CURRENCY_SYMBOLS) {
+    return CURRENCY_SYMBOLS[currency as SupportedCurrency];
+  }
+
+  // Check custom currencies
+  const customCurrencies = useCurrencyStore.getState().customCurrencies;
+  const customCurrency = customCurrencies[currency];
+  if (customCurrency) {
+    return customCurrency.symbol;
+  }
+
+  // Fallback to currency code
+  return currency;
+}
+
+/**
+ * Get the name for any currency (built-in or custom).
+ */
+export function getCurrencyName(currency: string): string {
+  // Check built-in currencies first
+  if (currency in CURRENCY_NAMES) {
+    return CURRENCY_NAMES[currency as SupportedCurrency];
+  }
+
+  // Check custom currencies
+  const customCurrencies = useCurrencyStore.getState().customCurrencies;
+  const customCurrency = customCurrencies[currency];
+  if (customCurrency) {
+    return customCurrency.name;
+  }
+
+  // Fallback to currency code
+  return currency;
+}
+
+/**
+ * Get metadata for a custom currency.
+ */
+export function getCurrencyMetadata(currency: string): CurrencyMetadata | undefined {
+  const customCurrencies = useCurrencyStore.getState().customCurrencies;
+  return customCurrencies[currency];
+}
+
+/**
+ * Get the number of decimal places for a currency (for converting from smallest unit).
+ * Used when parsing amounts from wei/smallest unit format.
+ *
+ * @param currency - Currency code
+ * @returns Number of decimal places (e.g., 18 for ETH/wei, 2 for USD cents, 0 for JPY)
+ */
+export function getCurrencyDecimalPlaces(currency: string): number {
+  // Check custom currencies first
+  const customCurrencies = useCurrencyStore.getState().customCurrencies;
+  const customMetadata = customCurrencies[currency];
+  if (customMetadata?.decimals !== undefined) {
+    return customMetadata.decimals;
+  }
+
+  // Built-in currencies with 18 decimals (wei-like)
+  if (currency === "WIN" || currency === "ETH" || currency === "SOL" || currency === "B3") {
+    return 18;
+  }
+
+  // Fiat currencies with cent-like decimals
+  if (currency === "USD" || currency === "EUR" || currency === "GBP" || currency === "CAD" || currency === "AUD") {
+    return 2;
+  }
+
+  // Currencies without fractional units
+  if (currency === "JPY" || currency === "KRW") {
+    return 0;
+  }
+
+  // Default to 18 decimals (wei-like)
+  return 18;
+}