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

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 { useCurrencyStore, getCurrencySymbol, getCurrencyMetadata } from "../stores/currencyStore.js";
+import { CURRENCY_SYMBOLS, useCurrencyStore } from "../stores/currencyStore.js";
 const COINBASE_API_URL = "https://api.coinbase.com/v2/exchange-rates";
 const REFETCH_INTERVAL_MS = 30000;
 /**
@@ -37,10 +37,8 @@ async function fetchAllExchangeRates(baseCurrency) {
 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 from Coinbase API
-    const { data: apiExchangeRates } = useQuery({
+    // Fetch all exchange rates for the base currency
+    const { data: exchangeRates } = useQuery({
         queryKey: ["exchangeRates", baseCurrency],
         queryFn: () => fetchAllExchangeRates(baseCurrency),
         refetchInterval: REFETCH_INTERVAL_MS,
@@ -48,208 +46,155 @@ 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"];
     /**
-     * Get exchange rate between two currencies, checking custom rates first, then API rates.
-     * Supports chaining through base currency for custom currencies.
+     * Formats a numeric value as a currency string with proper conversion and formatting.
      *
-     * 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
+     * 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)
      *
-     * @param value - The numeric value to format
-     * @param sourceCurrency - The currency the value is currently in (e.g., "WIN", "B3", "USD")
+     * @param value - The numeric value to format (in base currency)
      * @param options - Optional formatting overrides
-     * @param options.decimals - Override number of decimal places for display
+     * @param options.decimals - Override number of decimal places
+     * @param options.currency - Override currency (bypasses conversion)
      * @returns Formatted currency string with appropriate symbol and decimal places
      *
      * @example
      * ```tsx
-     * // 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)
+     * 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"
      * ```
      */
-    const formatCurrencyValue = (value, sourceCurrency, options) => {
+    const formatCurrencyValue = (value, options) => {
+        const overrideCurrency = options?.currency;
         const overrideDecimals = options?.decimals;
-        // 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;
+        // Custom currency provided - bypass conversion and use simple formatting
+        if (overrideCurrency) {
+            const decimalsToUse = overrideDecimals !== undefined ? overrideDecimals : overrideCurrency === "B3" ? 0 : 2;
             const formatted = formatDisplayNumber(value, {
                 fractionDigits: decimalsToUse,
-                significantDigits: decimalsToUse === undefined ? 6 : undefined,
-                showSubscripts: customMetadata?.showSubscripts ?? false,
+                showSubscripts: false,
             });
-            const symbol = getCurrencySymbol(sourceCurrency);
-            const usePrefix = customMetadata?.prefixSymbol ?? ["USD", "EUR", "GBP", "CAD", "AUD"].includes(sourceCurrency);
-            return usePrefix ? `${symbol}${formatted}` : `${formatted} ${symbol}`;
+            return `${formatted} ${overrideCurrency}`;
         }
-        // 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);
+        // Custom decimals for base currency without conversion
+        if (overrideDecimals !== undefined && selectedCurrency === baseCurrency) {
             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}`;
         }
-        else if (customMetadata) {
-            formatted = formatDisplayNumber(convertedValue, {
-                fractionDigits: customMetadata.decimals,
-                significantDigits: customMetadata.decimals === undefined ? 6 : undefined,
-                showSubscripts: customMetadata.showSubscripts ?? false,
+        // If showing base currency, no conversion needed
+        if (selectedCurrency === baseCurrency || !exchangeRate) {
+            const formatted = formatDisplayNumber(value, {
+                significantDigits: baseCurrency === "B3" ? 6 : 8,
+                showSubscripts: true,
             });
+            return `${formatted} ${baseCurrency}`;
         }
-        else if (selectedCurrency === "JPY" || selectedCurrency === "KRW") {
+        // 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
             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,
             });
         }
-        return usePrefix ? `${symbol}${formatted}` : `${formatted} ${symbol}`;
+        // Apply currency symbol with correct positioning
+        if (prefixCurrencies.includes(selectedCurrency)) {
+            return `${symbol}${formatted}`;
+        }
+        else {
+            // Suffix currencies: JPY, KRW, ETH, SOL, B3
+            return `${formatted} ${symbol}`;
+        }
     };
     /**
      * Formats a tooltip value showing the alternate currency representation.
      *
-     * 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
+     * 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
      *
      * @param value - The numeric value to format
-     * @param sourceCurrency - The currency the value is currently in
+     * @param customCurrency - Optional custom currency override
      * @returns Formatted tooltip string
      *
      * @example
      * ```tsx
-     * // 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"
+     * formatTooltipValue(100) // Returns "$150.00 USD" if displaying B3 with rate 1.5
+     * formatTooltipValue(100, "ETH") // Returns "100.0000 ETH" if custom currency
      * ```
      */
-    const formatTooltipValue = (value, sourceCurrency) => {
+    const formatTooltipValue = (value, customCurrency) => {
+        const displayCurrency = customCurrency || selectedCurrency;
         const absoluteValue = Math.abs(value);
-        // 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}`;
+        // 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}`;
+            }
         }
-        // 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, {
+        // Showing base currency - display USD equivalent
+        if (displayCurrency === baseCurrency) {
+            const usdValue = usdRate ? absoluteValue * usdRate : absoluteValue;
+            const formatted = formatDisplayNumber(usdValue, {
                 significantDigits: 6,
-                showSubscripts: getCurrencyMetadata(sourceCurrency)?.showSubscripts ?? false,
+                fractionDigits: usdValue < 1000 ? 2 : undefined,
+                showSubscripts: true,
             });
-            const symbol = getCurrencySymbol(sourceCurrency);
-            return `${formatted} ${symbol}`;
+            return `$${formatted} USD`;
         }
-        const usdValue = absoluteValue * usdRate;
-        const formatted = formatDisplayNumber(usdValue, {
-            significantDigits: 6,
-            fractionDigits: usdValue < 1000 ? 2 : undefined,
+        // Showing other currency - display base currency equivalent
+        const formatted = formatDisplayNumber(absoluteValue, {
+            significantDigits: baseCurrency === "B3" ? 6 : 8,
             showSubscripts: true,
         });
-        return `$${formatted} USD`;
+        return `${formatted} ${baseCurrency}`;
     };
     return {
         /** Currently selected display currency */
@@ -263,12 +208,8 @@ export function useCurrencyConversion() {
         /** Format a tooltip value showing alternate currency representation */
         formatTooltipValue,
         /** Symbol for the currently selected currency (e.g., "$", "€", "ETH") */
-        selectedCurrencySymbol: getCurrencySymbol(selectedCurrency),
+        selectedCurrencySymbol: CURRENCY_SYMBOLS[selectedCurrency],
         /** Symbol for the base currency */
-        baseCurrencySymbol: getCurrencySymbol(baseCurrency),
-        /** Get exchange rate between any two currencies */
-        getExchangeRate,
-        /** All registered custom currencies */
-        customCurrencies,
+        baseCurrencySymbol: CURRENCY_SYMBOLS[baseCurrency],
     };
 }

package/dist/esm/shared/react/stores/currencyStore.d.ts

@@ -1,36 +1,8 @@
 /**
- * Built-in supported currencies for display and conversion.
+ * 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,51 +17,24 @@ 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: 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[];
+    selectedCurrency: SupportedCurrency;
+    baseCurrency: SupportedCurrency;
+    setSelectedCurrency: (currency: SupportedCurrency) => void;
+    setBaseCurrency: (currency: SupportedCurrency) => void;
 }
 /**
  * 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, 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');
+ * const { selectedCurrency, setSelectedCurrency } = useCurrencyStore();
+ * // Change display currency to USD
+ * setSelectedCurrency('USD');
  * ```
  */
 export declare const useCurrencyStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<CurrencyState>, "persist"> & {
@@ -103,24 +48,4 @@ 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,158 +35,20 @@ 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, 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');
+ * const { selectedCurrency, setSelectedCurrency } = useCurrencyStore();
+ * // Change display currency to USD
+ * setSelectedCurrency('USD');
  * ```
  */
-export const useCurrencyStore = create()(persist((set, get) => ({
+export const useCurrencyStore = create()(persist(set => ({
     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: 3,
+    version: 2,
 }));
-/**
- * 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/index.d.ts

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