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

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 { useCurrencyStore, getCurrencySymbol, getCurrencyMetadata } from "../stores/currencyStore";
+import { CURRENCY_SYMBOLS, useCurrencyStore } from "../stores/currencyStore";
 
 const COINBASE_API_URL = "https://api.coinbase.com/v2/exchange-rates";
 const REFETCH_INTERVAL_MS = 30000;
@@ -47,11 +47,9 @@ 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 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,
@@ -60,163 +58,93 @@ export function useCurrencyConversion() {
     retryDelay: attemptIndex => Math.min(1000 * 2 ** attemptIndex, REFETCH_INTERVAL_MS),
   });
 
-  /**
-   * 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);
+  // 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 automatic conversion.
+   * Formats a numeric value as a currency string with proper conversion and formatting.
    *
-   * 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: number, sourceCurrency: string, options?: { decimals?: number }): string => {
+  const formatCurrencyValue = (value: number, options?: { decimals?: number; currency?: string }): string => {
+    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);
+    // Custom decimals for base currency without conversion
+    if (overrideDecimals !== undefined && selectedCurrency === baseCurrency) {
+      const formatted = formatDisplayNumber(value, {
+        fractionDigits: overrideDecimals,
+        showSubscripts: false,
+      });
+      return `${formatted} ${baseCurrency}`;
+    }
 
-    // If no conversion rate available, display in source currency
-    if (conversionRate === undefined) {
-      const customMetadata = getCurrencyMetadata(sourceCurrency);
+    // If showing base currency, no conversion needed
+    if (selectedCurrency === baseCurrency || !exchangeRate) {
       const formatted = formatDisplayNumber(value, {
-        significantDigits: 6,
-        showSubscripts: customMetadata?.showSubscripts ?? false,
+        significantDigits: baseCurrency === "B3" ? 6 : 8,
+        showSubscripts: true,
       });
-      const symbol = getCurrencySymbol(sourceCurrency);
-      return `${formatted} ${symbol}`;
+      return `${formatted} ${baseCurrency}`;
     }
 
-    // Convert value
-    const convertedValue = value * conversionRate;
+    // Convert value using current exchange rate
+    const convertedValue = value * exchangeRate;
+    const symbol = CURRENCY_SYMBOLS[selectedCurrency];
 
-    // 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);
+    // Currencies that display symbol before the number (e.g., $100.00)
+    const prefixCurrencies = ["USD", "EUR", "GBP", "CAD", "AUD"];
 
     let formatted: string;
 
-    // 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") {
+    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,
@@ -224,62 +152,71 @@ export function useCurrencyConversion() {
       });
     }
 
-    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: number, sourceCurrency: string): string => {
+  const formatTooltipValue = (value: number, customCurrency?: string): string => {
+    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 {
@@ -294,12 +231,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/src/shared/react/stores/currencyStore.ts

@@ -2,41 +2,11 @@ import { create } from "zustand";
 import { persist } from "zustand/middleware";
 
 /**
- * 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.
@@ -75,214 +45,38 @@ 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: 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 const useCurrencyStore = create<CurrencyState>()(
   persist(
-    (set, get) => ({
+    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: 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: 3,
+      version: 2,
     },
   ),
 );
-
-/**
- * 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;
-}

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

@@ -1,7 +0,0 @@
-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/cjs/anyspend/utils/accountStore.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useGlobalWalletState = void 0;
-const zustand_1 = require("zustand");
-exports.useGlobalWalletState = (0, zustand_1.create)(set => ({
-    globalAccountWallet: undefined,
-    setGlobalAccountWallet: account => set({ globalAccountWallet: account }),
-}));

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

@@ -1,7 +0,0 @@
-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/esm/anyspend/utils/accountStore.js

@@ -1,5 +0,0 @@
-import { create } from "zustand";
-export const useGlobalWalletState = create(set => ({
-    globalAccountWallet: undefined,
-    setGlobalAccountWallet: account => set({ globalAccountWallet: account }),
-}));

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

@@ -1,7 +0,0 @@
-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 {};