auramaxx 0.0.1

package/src/components/vault/credentialFormName.ts

@@ -0,0 +1,91 @@
+type FormType = 'login' | 'card' | 'note' | 'plain_note' | 'hot_wallet' | 'apikey' | 'oauth2' | 'ssh' | 'gpg' | 'custom';
+
+type NameInputs = {
+  type: FormType;
+  name: string;
+  apiKeyName: string;
+  username: string;
+  url: string;
+  noteContent: string;
+  customFieldKey: string;
+  hotWalletChain: string;
+  cardholder: string;
+  cardNumber: string;
+  oauth2TokenEndpoint: string;
+  sshHostsInput: string;
+  gpgKeyId: string;
+  gpgUidEmail: string;
+};
+
+export function deriveCredentialName(inputs: NameInputs): string {
+  const {
+    type,
+    name,
+    apiKeyName,
+    username,
+    url,
+    noteContent,
+    customFieldKey,
+    hotWalletChain,
+    cardholder,
+    cardNumber,
+    oauth2TokenEndpoint,
+    sshHostsInput,
+    gpgKeyId,
+    gpgUidEmail,
+  } = inputs;
+  const safeHostsInput = sshHostsInput || '';
+  const safeCardholder = cardholder || '';
+  const safeCardNumber = cardNumber || '';
+  const safeOauth2TokenEndpoint = oauth2TokenEndpoint || '';
+  const safeGpgKeyId = gpgKeyId || '';
+  const safeGpgUidEmail = gpgUidEmail || '';
+  const trimmedHosts = safeHostsInput
+    .split(/\n|,/)
+    .map((host) => host.trim())
+    .filter(Boolean);
+  const derivedNameByType: Partial<Record<FormType, string>> = {
+    plain_note: noteContent.trim().slice(0, 48),
+    apikey: apiKeyName.trim(),
+    login: username.trim() || url.trim() || 'Login',
+    note: noteContent.trim().slice(0, 48),
+    hot_wallet: hotWalletChain.trim() ? `Hot Wallet (${hotWalletChain.trim().toUpperCase()})` : 'Hot Wallet',
+    custom: customFieldKey.trim(),
+    card: safeCardholder.trim() || (safeCardNumber.trim() ? `Card ••••${safeCardNumber.trim().slice(-4)}` : 'Card'),
+    oauth2: safeOauth2TokenEndpoint.trim() || 'OAuth2',
+    ssh: trimmedHosts[0] || 'SSH Key',
+    gpg: safeGpgKeyId.trim() || safeGpgUidEmail.trim() || 'GPG Key',
+  };
+  return name.trim() || derivedNameByType[type] || '';
+}
+
+export function canDeriveName(inputs: Omit<NameInputs, 'name'>): boolean {
+  const {
+    type,
+    apiKeyName,
+    username,
+    url,
+    noteContent,
+    customFieldKey,
+    hotWalletChain,
+    cardholder,
+    cardNumber,
+    oauth2TokenEndpoint,
+    sshHostsInput,
+    gpgKeyId,
+    gpgUidEmail,
+  } = inputs;
+
+  return (
+    (type === 'apikey' && !!apiKeyName.trim())
+    || (type === 'plain_note' && !!noteContent.trim())
+    || (type === 'login' && (!!username.trim() || !!url.trim()))
+    || (type === 'note' && !!noteContent.trim())
+    || (type === 'hot_wallet' && (!!hotWalletChain.trim() || true))
+    || (type === 'custom' && !!customFieldKey.trim())
+    || (type === 'card' && (!!cardholder?.trim() || !!cardNumber?.trim()))
+    || (type === 'oauth2' && !!oauth2TokenEndpoint?.trim())
+    || (type === 'ssh' && !!sshHostsInput?.trim())
+    || (type === 'gpg' && (!!gpgKeyId?.trim() || !!gpgUidEmail?.trim()))
+  );
+}

package/src/components/vault/hooks/useVaultKeyboardShortcuts.ts

@@ -0,0 +1,69 @@
+import { RefObject, useEffect } from 'react';
+import { CredentialMeta } from '../types';
+
+type Params = {
+  filteredCredentials: CredentialMeta[];
+  selectedId: string | null;
+  isMobile: boolean;
+  searchRef: RefObject<HTMLInputElement | null>;
+  onCreateCredential: () => void;
+  setSelectedId: (id: string) => void;
+  setMobileDetailOpen: (open: boolean) => void;
+};
+
+export function useVaultKeyboardShortcuts({
+  filteredCredentials,
+  selectedId,
+  isMobile,
+  searchRef,
+  onCreateCredential,
+  setSelectedId,
+  setMobileDetailOpen,
+}: Params) {
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      const target = e.target as HTMLElement;
+      const isInput = target.tagName === 'INPUT' || target.tagName === 'TEXTAREA';
+      const isEditable = isInput || target.isContentEditable;
+
+      const lowerKey = e.key.toLowerCase();
+      if ((!isEditable && (e.metaKey || e.ctrlKey) && lowerKey === 'k') || (!isEditable && e.key === '/')) {
+        e.preventDefault();
+        searchRef.current?.focus();
+        return;
+      }
+
+      const isCreateShortcut = !isEditable
+        && (e.metaKey || e.ctrlKey)
+        && e.altKey
+        && (lowerKey === 'n' || e.code === 'KeyN');
+      if (isCreateShortcut) {
+        e.preventDefault();
+        onCreateCredential();
+        return;
+      }
+
+      if (!isInput && (e.key === 'ArrowDown' || e.key === 'ArrowUp')) {
+        e.preventDefault();
+        const currentIndex = filteredCredentials.findIndex((c) => c.id === selectedId);
+        if (e.key === 'ArrowDown') {
+          const next = currentIndex + 1;
+          if (next < filteredCredentials.length) setSelectedId(filteredCredentials[next].id);
+        } else {
+          const prev = currentIndex - 1;
+          if (prev >= 0) setSelectedId(filteredCredentials[prev].id);
+        }
+      }
+
+      if (!isInput && e.key === 'Enter' && filteredCredentials.length > 0) {
+        e.preventDefault();
+        const nextId = selectedId ?? filteredCredentials[0].id;
+        setSelectedId(nextId);
+        if (isMobile) setMobileDetailOpen(true);
+      }
+    };
+
+    window.addEventListener('keydown', handleKeyDown);
+    return () => window.removeEventListener('keydown', handleKeyDown);
+  }, [filteredCredentials, selectedId, isMobile, searchRef, onCreateCredential, setSelectedId, setMobileDetailOpen]);
+}

package/src/components/vault/types.ts

@@ -0,0 +1,56 @@
+export interface CredentialMeta {
+  id: string;
+  vaultId: string;
+  type: string;
+  name: string;
+  meta: {
+    url?: string;
+    username?: string;
+    tags?: string[];
+    favorite?: boolean;
+    last4?: string;
+    brand?: string;
+    cardholder?: string;
+    [k: string]: unknown;
+  };
+  createdAt: string;
+  updatedAt: string;
+  archivedAt?: string;
+  deletedAt?: string;
+}
+
+export interface VaultInfo {
+  id: string;
+  name?: string;
+  mode: 'primary' | 'linked' | 'independent';
+  parentVaultId?: string;
+  linkedTo?: string;
+  isUnlocked: boolean;
+  isPrimary: boolean;
+  credentialCount: number;
+}
+
+export interface WalletLinkMetaV1 {
+  version: 1;
+  walletAddress: string;
+  chain: string;
+  tier: 'cold' | 'hot';
+  label?: string;
+  source: 'existing' | 'created';
+  linkedAt: string;
+}
+
+export type CredentialType = 'login' | 'card' | 'note' | 'plain_note' | 'hot_wallet' | 'api' | 'apikey' | 'custom' | 'passkey' | 'oauth2' | 'ssh' | 'gpg';
+export type CredentialLifecycleFilter = 'active' | 'archive' | 'recently_deleted';
+export type CredentialWithLocation = CredentialMeta & { location: CredentialLifecycleFilter };
+
+export type CategoryFilter = 'all' | 'login' | 'card' | 'note' | 'plain_note' | 'hot_wallet' | 'api' | 'apikey' | 'custom' | 'passkey' | 'oauth2' | 'ssh' | 'gpg';
+
+export interface VaultFilters {
+  vaultId: string | null;
+  category: CategoryFilter;
+  tag: string | null;
+  search: string;
+  favoritesOnly: boolean;
+  lifecycle: CredentialLifecycleFilter;
+}

package/src/context/AuthContext.tsx

@@ -0,0 +1,365 @@
+'use client';
+
+import { createContext, useContext, useState, useCallback, ReactNode, useEffect } from 'react';
+import { api, Api } from '@/lib/api';
+import { discardVaultKeypair } from '@/lib/vault-crypto';
+
+export interface ApiKey {
+  id: string;
+  service: string;
+  name: string;
+  key: string;
+  keyMasked: string;
+  createdAt?: string;
+}
+
+export interface ChainConfig {
+  rpc: string;
+  chainId: number;
+  explorer: string;
+}
+
+type TokenPersistence = 'session' | 'local';
+
+interface SetTokenOptions {
+  persist?: TokenPersistence;
+}
+
+// Alchemy RPC paths by chain
+const ALCHEMY_PATHS: Record<string, { path: string; chainId: number; explorer: string }> = {
+  base: { path: 'base-mainnet', chainId: 8453, explorer: 'https://basescan.org' },
+  ethereum: { path: 'eth-mainnet', chainId: 1, explorer: 'https://etherscan.io' },
+  arbitrum: { path: 'arb-mainnet', chainId: 42161, explorer: 'https://arbiscan.io' },
+  optimism: { path: 'opt-mainnet', chainId: 10, explorer: 'https://optimistic.etherscan.io' },
+  solana: { path: 'solana-mainnet', chainId: 0, explorer: 'https://solscan.io' },
+  'solana-devnet': { path: 'solana-devnet', chainId: 0, explorer: 'https://solscan.io/?cluster=devnet' },
+};
+
+// Public RPC fallbacks (default chains: base, ethereum, and solana)
+const PUBLIC_RPCS: Record<string, ChainConfig> = {
+  base: { rpc: 'https://mainnet.base.org', chainId: 8453, explorer: 'https://basescan.org' },
+  ethereum: { rpc: 'https://eth.llamarpc.com', chainId: 1, explorer: 'https://etherscan.io' },
+  solana: { rpc: 'https://api.mainnet-beta.solana.com', chainId: 0, explorer: 'https://solscan.io' },
+  'solana-devnet': { rpc: 'https://api.devnet.solana.com', chainId: 0, explorer: 'https://solscan.io/?cluster=devnet' },
+};
+
+interface AuthContextValue {
+  token: string | null;
+  isUnlocked: boolean;
+  setToken: (token: string | null, options?: SetTokenOptions) => void;
+  clearToken: () => void;
+  apiKeys: ApiKey[];
+  apiKeysLoading: boolean;
+  refreshApiKeys: () => Promise<void>;
+  getApiKey: (service: string, name?: string) => string | null;
+  getRpcUrl: (chain?: string) => string;
+  getChainConfig: (chain?: string) => ChainConfig;
+  // Chain overrides (custom RPC URLs stored in DB)
+  chainOverrides: Record<string, ChainConfig>;
+  chainOverridesLoading: boolean;
+  refreshChainOverrides: () => Promise<void>;
+  saveChainOverride: (chain: string, config: ChainConfig) => Promise<void>;
+  removeChainOverride: (chain: string) => Promise<void>;
+  // All configured chains (public defaults + DB overrides)
+  getConfiguredChains: () => Record<string, ChainConfig>;
+}
+
+const AuthContext = createContext<AuthContextValue | null>(null);
+
+// Storage key for persisting token across page reloads
+const TOKEN_STORAGE_KEY = 'auramaxx_admin_token';
+
+const getStoredToken = (): { token: string | null; persist: TokenPersistence | null } => {
+  if (typeof window === 'undefined') return { token: null, persist: null };
+  const localToken = localStorage.getItem(TOKEN_STORAGE_KEY);
+  if (localToken) return { token: localToken, persist: 'local' };
+  const sessionToken = sessionStorage.getItem(TOKEN_STORAGE_KEY);
+  if (sessionToken) return { token: sessionToken, persist: 'session' };
+  return { token: null, persist: null };
+};
+
+const clearStoredToken = () => {
+  if (typeof window === 'undefined') return;
+  sessionStorage.removeItem(TOKEN_STORAGE_KEY);
+  localStorage.removeItem(TOKEN_STORAGE_KEY);
+};
+
+const persistToken = (token: string, persist: TokenPersistence) => {
+  if (typeof window === 'undefined') return;
+  if (persist === 'local') {
+    localStorage.setItem(TOKEN_STORAGE_KEY, token);
+    sessionStorage.removeItem(TOKEN_STORAGE_KEY);
+    return;
+  }
+  sessionStorage.setItem(TOKEN_STORAGE_KEY, token);
+  localStorage.removeItem(TOKEN_STORAGE_KEY);
+};
+
+interface AuthProviderProps {
+  children: ReactNode;
+}
+
+export function AuthProvider({ children }: AuthProviderProps) {
+  const [token, setTokenState] = useState<string | null>(null);
+  const [apiKeys, setApiKeys] = useState<ApiKey[]>([]);
+  const [apiKeysLoading, setApiKeysLoading] = useState(false);
+  const [chainOverrides, setChainOverrides] = useState<Record<string, ChainConfig>>({});
+  const [chainOverridesLoading, setChainOverridesLoading] = useState(false);
+
+  // Load token from storage on mount (local preferred over session)
+  useEffect(() => {
+    const { token: storedToken } = getStoredToken();
+    if (storedToken) {
+      setTokenState(storedToken);
+    }
+  }, []);
+
+  // Fetch API keys when token is available
+  const refreshApiKeys = useCallback(async () => {
+    if (!token) {
+      setApiKeys([]);
+      return;
+    }
+    setApiKeysLoading(true);
+    try {
+      const data = await api.get<{ success: boolean; apiKeys: ApiKey[] }>(Api.Wallet, '/apikeys');
+      if (data.success && data.apiKeys) {
+        setApiKeys(data.apiKeys);
+      }
+    } catch (err) {
+      // If the token is invalid/expired (server restarted, new SIGNING_KEY), clear it
+      const status = (err as Error & { status?: number }).status;
+      if (status === 401 || status === 403) {
+        setTokenState(null);
+        clearStoredToken();
+        setApiKeys([]);
+      }
+      console.error('[AuthContext] Failed to fetch API keys:', err);
+    } finally {
+      setApiKeysLoading(false);
+    }
+  }, [token]);
+
+  // Load API keys when token changes
+  useEffect(() => {
+    if (token) {
+      refreshApiKeys();
+    } else {
+      setApiKeys([]);
+    }
+  }, [token, refreshApiKeys]);
+
+  // Fetch chain overrides from workspace config
+  const refreshChainOverrides = useCallback(async () => {
+    if (!token) {
+      setChainOverrides({});
+      setChainOverridesLoading(false);
+      return;
+    }
+
+    setChainOverridesLoading(true);
+    try {
+      const data = await api.get<{ success: boolean; config: { chainOverrides: Record<string, ChainConfig> } }>(
+        Api.Workspace,
+        '/workspace/config'
+      );
+      if (data.success && data.config) {
+        setChainOverrides(data.config.chainOverrides || {});
+      }
+    } catch (err) {
+      const status = (err as Error & { status?: number }).status;
+      if (status === 401 || status === 403 || status === 404) {
+        setChainOverrides({});
+      } else {
+        console.error('[AuthContext] Failed to fetch chain overrides:', err);
+      }
+    } finally {
+      setChainOverridesLoading(false);
+    }
+  }, [token]);
+
+  // Load chain overrides when auth state changes
+  useEffect(() => {
+    if (token) {
+      refreshChainOverrides();
+      return;
+    }
+    setChainOverrides({});
+    setChainOverridesLoading(false);
+  }, [token, refreshChainOverrides]);
+
+  // Save a chain override
+  const saveChainOverride = useCallback(async (chain: string, config: ChainConfig) => {
+    const newOverrides = { ...chainOverrides, [chain]: config };
+    try {
+      const data = await api.post<{ success: boolean; config: { chainOverrides: Record<string, ChainConfig> } }>(
+        Api.Workspace,
+        '/workspace/config',
+        { chainOverrides: newOverrides }
+      );
+      if (data.success && data.config) {
+        setChainOverrides(data.config.chainOverrides || {});
+      }
+    } catch (err) {
+      console.error('[AuthContext] Failed to save chain override:', err);
+      throw err;
+    }
+  }, [chainOverrides]);
+
+  // Remove a chain override
+  const removeChainOverride = useCallback(async (chain: string) => {
+    const newOverrides = { ...chainOverrides };
+    delete newOverrides[chain];
+    try {
+      const data = await api.post<{ success: boolean; config: { chainOverrides: Record<string, ChainConfig> } }>(
+        Api.Workspace,
+        '/workspace/config',
+        { chainOverrides: newOverrides }
+      );
+      if (data.success && data.config) {
+        setChainOverrides(data.config.chainOverrides || {});
+      }
+    } catch (err) {
+      console.error('[AuthContext] Failed to remove chain override:', err);
+      throw err;
+    }
+  }, [chainOverrides]);
+
+  const setToken = useCallback((newToken: string | null, options?: SetTokenOptions) => {
+    setTokenState(newToken);
+    if (!newToken) {
+      clearStoredToken();
+      return;
+    }
+    const currentPersistence = getStoredToken().persist;
+    const persist = options?.persist ?? currentPersistence ?? 'session';
+    persistToken(newToken, persist);
+  }, []);
+
+  const clearToken = useCallback(() => {
+    discardVaultKeypair();
+    setToken(null);
+  }, [setToken]);
+
+  // Get an API key by service and optional name
+  const getApiKey = useCallback((service: string, name?: string): string | null => {
+    const key = apiKeys.find(k =>
+      k.service.toLowerCase() === service.toLowerCase() &&
+      (!name || k.name.toLowerCase() === name.toLowerCase())
+    );
+    return key?.key || null;
+  }, [apiKeys]);
+
+  // Get RPC URL for a chain: override → Alchemy → public fallback
+  const getRpcUrl = useCallback((chain: string = 'base'): string => {
+    // 1. Check for custom override
+    if (chainOverrides[chain]?.rpc) {
+      return chainOverrides[chain].rpc;
+    }
+
+    // 2. Check for Alchemy API key
+    const alchemyKey = getApiKey('alchemy');
+    const alchemyConfig = ALCHEMY_PATHS[chain];
+    if (alchemyKey && alchemyConfig) {
+      return `https://${alchemyConfig.path}.g.alchemy.com/v2/${alchemyKey}`;
+    }
+
+    // 3. Fallback to public RPC
+    return PUBLIC_RPCS[chain]?.rpc || PUBLIC_RPCS.base.rpc;
+  }, [chainOverrides, getApiKey]);
+
+  // Get full chain config: override → Alchemy → public fallback
+  const getChainConfig = useCallback((chain: string = 'base'): ChainConfig => {
+    // 1. Check for custom override
+    if (chainOverrides[chain]) {
+      return chainOverrides[chain];
+    }
+
+    // 2. Check for Alchemy API key
+    const alchemyKey = getApiKey('alchemy');
+    const alchemyConfig = ALCHEMY_PATHS[chain];
+    if (alchemyKey && alchemyConfig) {
+      return {
+        rpc: `https://${alchemyConfig.path}.g.alchemy.com/v2/${alchemyKey}`,
+        chainId: alchemyConfig.chainId,
+        explorer: alchemyConfig.explorer,
+      };
+    }
+
+    // 3. Fallback to public RPC
+    return PUBLIC_RPCS[chain] || PUBLIC_RPCS.base;
+  }, [chainOverrides, getApiKey]);
+
+  // Get all configured chains (merges overrides, Alchemy-supported, and public RPCs)
+  // Get all configured chains: public defaults + DB overrides
+  // RPC resolution for each: DB custom RPC → Alchemy → public fallback
+  const getConfiguredChains = useCallback((): Record<string, ChainConfig> => {
+    const result: Record<string, ChainConfig> = {};
+    const alchemyKey = getApiKey('alchemy');
+
+    // Helper to resolve RPC URL for a chain
+    const resolveRpc = (chain: string, baseConfig: ChainConfig): string => {
+      // 1. If chain has custom RPC in DB, use it
+      if (chainOverrides[chain]?.rpc) {
+        return chainOverrides[chain].rpc;
+      }
+      // 2. If Alchemy key exists and chain is supported, use Alchemy
+      const alchemyConfig = ALCHEMY_PATHS[chain];
+      if (alchemyKey && alchemyConfig) {
+        return `https://${alchemyConfig.path}.g.alchemy.com/v2/${alchemyKey}`;
+      }
+      // 3. Fallback to hardcoded public RPC
+      return baseConfig.rpc;
+    };
+
+    // Add public defaults (base, ethereum) with resolved RPCs
+    for (const [chain, config] of Object.entries(PUBLIC_RPCS)) {
+      result[chain] = {
+        ...config,
+        rpc: resolveRpc(chain, config),
+      };
+    }
+
+    // Add any user-added chains from DB (not in PUBLIC_RPCS)
+    for (const [chain, config] of Object.entries(chainOverrides)) {
+      if (!PUBLIC_RPCS[chain]) {
+        result[chain] = config;
+      }
+    }
+
+    return result;
+  }, [chainOverrides, getApiKey]);
+
+  const value: AuthContextValue = {
+    token,
+    isUnlocked: !!token,
+    setToken,
+    clearToken,
+    apiKeys,
+    apiKeysLoading,
+    refreshApiKeys,
+    getApiKey,
+    getRpcUrl,
+    getChainConfig,
+    chainOverrides,
+    chainOverridesLoading,
+    refreshChainOverrides,
+    saveChainOverride,
+    removeChainOverride,
+    getConfiguredChains,
+  };
+
+  return (
+    <AuthContext.Provider value={value}>
+      {children}
+    </AuthContext.Provider>
+  );
+}
+
+export function useAuth(): AuthContextValue {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error('useAuth must be used within an AuthProvider');
+  }
+  return context;
+}

package/src/context/PriceContext.tsx

@@ -0,0 +1,113 @@
+'use client';
+
+import React, { createContext, useContext, useEffect, useState, useCallback } from 'react';
+import { api, Api } from '@/lib/api';
+
+interface PriceContextType {
+  ethPrice: number | null;
+  solPrice: number | null;
+  loading: boolean;
+  error: string | null;
+  lastUpdated: Date | null;
+  refresh: () => void;
+  formatUsd: (ethAmount: string | number | undefined) => string;
+  formatUsdForChain: (amount: string | number | undefined, chain: string) => string;
+}
+
+const PriceContext = createContext<PriceContextType>({
+  ethPrice: null,
+  solPrice: null,
+  loading: true,
+  error: null,
+  lastUpdated: null,
+  refresh: () => {},
+  formatUsd: () => '',
+  formatUsdForChain: () => '',
+});
+
+export const usePrice = () => useContext(PriceContext);
+
+const REFRESH_INTERVAL = 60000; // 60 seconds
+
+interface PriceResponse {
+  success: boolean;
+  priceUsd?: string;
+  error?: string;
+}
+
+function isSolanaChain(chain: string): boolean {
+  return chain === 'solana' || chain === 'solana-devnet';
+}
+
+export const PriceProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+  const [ethPrice, setEthPrice] = useState<number | null>(null);
+  const [solPrice, setSolPrice] = useState<number | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [lastUpdated, setLastUpdated] = useState<Date | null>(null);
+
+  const fetchAllPrices = useCallback(async () => {
+    try {
+      const [ethRes, solRes] = await Promise.all([
+        api.get<PriceResponse>(Api.Wallet, '/price/native', { chain: 'base' }).catch(() => null),
+        api.get<PriceResponse>(Api.Wallet, '/price/native', { chain: 'solana' }).catch(() => null),
+      ]);
+
+      if (ethRes?.success && ethRes.priceUsd) {
+        const price = parseFloat(ethRes.priceUsd);
+        if (!isNaN(price)) setEthPrice(price);
+      }
+
+      if (solRes?.success && solRes.priceUsd) {
+        const price = parseFloat(solRes.priceUsd);
+        if (!isNaN(price)) setSolPrice(price);
+      }
+
+      setLastUpdated(new Date());
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Price fetch failed');
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    fetchAllPrices();
+    const interval = setInterval(fetchAllPrices, REFRESH_INTERVAL);
+    return () => clearInterval(interval);
+  }, [fetchAllPrices]);
+
+  const formatAmountToUsd = useCallback((amount: string | number | undefined, price: number | null): string => {
+    if (amount === undefined || amount === null || amount === '') return '';
+    if (price === null) return '';
+
+    const numStr = String(amount).replace(/[^0-9.-]/g, '');
+    const num = parseFloat(numStr);
+
+    if (isNaN(num) || num === 0) return '$0';
+
+    const usd = num * price;
+
+    if (usd < 0.01) return '<$0.01';
+    if (usd < 1) return `$${usd.toFixed(2)}`;
+    if (usd < 1000) return `$${usd.toFixed(2)}`;
+    if (usd < 10000) return `$${usd.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+    return `$${usd.toLocaleString('en-US', { minimumFractionDigits: 0, maximumFractionDigits: 0 })}`;
+  }, []);
+
+  const formatUsd = useCallback((ethAmount: string | number | undefined): string => {
+    return formatAmountToUsd(ethAmount, ethPrice);
+  }, [ethPrice, formatAmountToUsd]);
+
+  const formatUsdForChain = useCallback((amount: string | number | undefined, chain: string): string => {
+    const price = isSolanaChain(chain) ? solPrice : ethPrice;
+    return formatAmountToUsd(amount, price);
+  }, [ethPrice, solPrice, formatAmountToUsd]);
+
+  return (
+    <PriceContext.Provider value={{ ethPrice, solPrice, loading, error, lastUpdated, refresh: fetchAllPrices, formatUsd, formatUsdForChain }}>
+      {children}
+    </PriceContext.Provider>
+  );
+};