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

package/dist/esm/shared/react/hooks/useCurrencyConversion.js

@@ -1,6 +1,6 @@
 import { useQuery } from "@tanstack/react-query";
 import { formatDisplayNumber } from "../../../shared/utils/number.js";
-import { CURRENCY_SYMBOLS, useCurrencyStore } from "../stores/currencyStore.js";
+import { useCurrencyStore, getCurrencySymbol, getCurrencyMetadata } from "../stores/currencyStore.js";
 const COINBASE_API_URL = "https://api.coinbase.com/v2/exchange-rates";
 const REFETCH_INTERVAL_MS = 30000;
 /**
@@ -37,8 +37,10 @@ async function fetchAllExchangeRates(baseCurrency) {
 export function useCurrencyConversion() {
     const selectedCurrency = useCurrencyStore(state => state.selectedCurrency);
     const baseCurrency = useCurrencyStore(state => state.baseCurrency);
-    // Fetch all exchange rates for the base currency
-    const { data: exchangeRates } = useQuery({
+    const getCustomExchangeRate = useCurrencyStore(state => state.getExchangeRate);
+    const customCurrencies = useCurrencyStore(state => state.customCurrencies);
+    // 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,
@@ -46,155 +48,208 @@ export function useCurrencyConversion() {
         retry: 3,
         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"];
     /**
-     * Formats a numeric value as a currency string with proper conversion and formatting.
+     * Get exchange rate between two currencies, checking custom rates first, then API rates.
+     * Supports chaining through base currency for custom currencies.
      *
-     * 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)
+     * 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, to) => {
+        // 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 automatic conversion.
+     *
+     * 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, options) => {
-        const overrideCurrency = options?.currency;
+    const formatCurrencyValue = (value, sourceCurrency, options) => {
         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}`;
+            const symbol = getCurrencySymbol(sourceCurrency);
+            const usePrefix = customMetadata?.prefixSymbol ?? ["USD", "EUR", "GBP", "CAD", "AUD"].includes(sourceCurrency);
+            return usePrefix ? `${symbol}${formatted}` : `${formatted} ${symbol}`;
         }
-        // Custom decimals for base currency without conversion
-        if (overrideDecimals !== undefined && selectedCurrency === baseCurrency) {
+        // 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: 6,
+                showSubscripts: customMetadata?.showSubscripts ?? false,
+            });
+            const symbol = getCurrencySymbol(sourceCurrency);
+            return `${formatted} ${symbol}`;
+        }
+        // Convert value
+        const convertedValue = value * conversionRate;
+        // 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;
+        // Apply formatting based on display currency
+        if (overrideDecimals !== undefined) {
+            formatted = formatDisplayNumber(convertedValue, {
                 fractionDigits: overrideDecimals,
                 showSubscripts: false,
             });
-            return `${formatted} ${baseCurrency}`;
         }
-        // If showing base currency, no conversion needed
-        if (selectedCurrency === baseCurrency || !exchangeRate) {
-            const formatted = formatDisplayNumber(value, {
-                significantDigits: baseCurrency === "B3" ? 6 : 8,
-                showSubscripts: true,
+        else if (customMetadata) {
+            formatted = formatDisplayNumber(convertedValue, {
+                fractionDigits: customMetadata.decimals,
+                significantDigits: customMetadata.decimals === undefined ? 6 : undefined,
+                showSubscripts: customMetadata.showSubscripts ?? false,
             });
-            return `${formatted} ${baseCurrency}`;
         }
-        // Convert value using current exchange rate
-        const convertedValue = value * exchangeRate;
-        const symbol = CURRENCY_SYMBOLS[selectedCurrency];
-        // Currencies that display symbol before the number (e.g., $100.00)
-        const prefixCurrencies = ["USD", "EUR", "GBP", "CAD", "AUD"];
-        let formatted;
-        if (selectedCurrency === "JPY" || selectedCurrency === "KRW") {
-            // Japanese Yen and Korean Won don't use decimal places
+        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,
                 showSubscripts: true,
             });
         }
-        // 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, customCurrency) => {
-        const displayCurrency = customCurrency || selectedCurrency;
+    const formatTooltipValue = (value, sourceCurrency) => {
         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 {
         /** Currently selected display currency */
@@ -208,8 +263,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/dist/esm/shared/react/stores/currencyStore.d.ts

@@ -1,8 +1,36 @@
 /**
- * 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.
@@ -17,24 +45,51 @@ export declare 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 declare const useCurrencyStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<CurrencyState>, "persist"> & {
@@ -48,4 +103,24 @@ export declare const useCurrencyStore: import("zustand").UseBoundStore<Omit<impo
         getOptions: () => Partial<import("zustand/middleware").PersistOptions<CurrencyState, CurrencyState>>;
     };
 }>;
+/**
+ * Get the symbol for any currency (built-in or custom).
+ */
+export declare function getCurrencySymbol(currency: string): string;
+/**
+ * Get the name for any currency (built-in or custom).
+ */
+export declare function getCurrencyName(currency: string): string;
+/**
+ * Get metadata for a custom currency.
+ */
+export declare function getCurrencyMetadata(currency: string): CurrencyMetadata | undefined;
+/**
+ * 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 declare function getCurrencyDecimalPlaces(currency: string): number;
 export {};

package/dist/esm/shared/react/stores/currencyStore.js

@@ -35,20 +35,158 @@ export const CURRENCY_NAMES = {
 /**
  * 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()(persist(set => ({
+export const useCurrencyStore = create()(persist((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 = {};
+            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 = {
+                ...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) {
+    // Check built-in currencies first
+    if (currency in CURRENCY_SYMBOLS) {
+        return CURRENCY_SYMBOLS[currency];
+    }
+    // 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) {
+    // Check built-in currencies first
+    if (currency in CURRENCY_NAMES) {
+        return CURRENCY_NAMES[currency];
+    }
+    // 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) {
+    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) {
+    // 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;
+}

package/dist/types/anyspend/utils/accountStore.d.ts

@@ -0,0 +1,7 @@
+import type { Wallet } from "thirdweb/wallets";
+interface GlobalWalletState {
+    globalAccountWallet?: Wallet;
+    setGlobalAccountWallet: (account?: Wallet) => void;
+}
+export declare const useGlobalWalletState: import("zustand").UseBoundStore<import("zustand").StoreApi<GlobalWalletState>>;
+export {};

package/dist/types/anyspend/utils/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./accountStore";
 export * from "./address";
 export * from "./chain";
 export * from "./format";

package/dist/types/shared/react/components/FormattedCurrency.d.ts

@@ -1,12 +1,12 @@
 interface FormattedCurrencyProps {
-    amount: number;
+    amount: string;
+    sourceCurrency: string;
     showChange?: boolean;
     showColor?: boolean;
     className?: string;
     subB3Icon?: boolean;
     clickable?: boolean;
     decimals?: number;
-    currency?: string;
 }
-export declare function FormattedCurrency({ amount, showChange, showColor, className, subB3Icon, clickable, decimals, currency, }: FormattedCurrencyProps): import("react/jsx-runtime").JSX.Element;
+export declare function FormattedCurrency({ amount, sourceCurrency, showChange, showColor, className, subB3Icon, clickable, decimals, }: FormattedCurrencyProps): import("react/jsx-runtime").JSX.Element;
 export {};