auramaxx 0.0.1

package/src/hooks/useBalances.ts

@@ -0,0 +1,129 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { ethers } from 'ethers';
+import { useAuth } from '@/context/AuthContext';
+
+interface BalanceMap {
+  [address: string]: string;
+}
+
+interface UseBalancesResult {
+  balances: BalanceMap;
+  loading: boolean;
+  error: string | null;
+  refetch: () => Promise<void>;
+}
+
+/**
+ * Hook to fetch ETH balances for multiple addresses using batch RPC calls
+ * Uses eth_getBalance with JSON-RPC batch request for efficiency
+ */
+export function useBalances(addresses: string[], chain?: string): UseBalancesResult {
+  const { getRpcUrl, getConfiguredChains } = useAuth();
+  const [balances, setBalances] = useState<BalanceMap>({});
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Track previous values to detect changes
+  const prevAddressesRef = useRef<string>('');
+  const prevRpcUrlRef = useRef<string>('');
+
+  const chains = getConfiguredChains();
+  const defaultChain = Object.keys(chains)[0] || 'base';
+  const targetChain = chain || defaultChain;
+
+  // Get current RPC URL for comparison
+  const rpcUrl = getRpcUrl(targetChain);
+
+  const fetchBalances = useCallback(async () => {
+    if (!addresses || addresses.length === 0) {
+      setBalances({});
+      return;
+    }
+
+    const currentRpcUrl = getRpcUrl(targetChain);
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      // Build batch request for all addresses
+      const batchRequest = addresses.map((address, index) => ({
+        jsonrpc: '2.0',
+        id: index,
+        method: 'eth_getBalance',
+        params: [address, 'latest'],
+      }));
+
+      const response = await fetch(currentRpcUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(batchRequest),
+      });
+
+      if (!response.ok) {
+        throw new Error(`RPC request failed: ${response.status}`);
+      }
+
+      const results = await response.json();
+
+      // Handle both array response (batch) and single response
+      const resultsArray = Array.isArray(results) ? results : [results];
+
+      // Sort by id to match original order
+      resultsArray.sort((a, b) => a.id - b.id);
+
+      const newBalances: BalanceMap = {};
+      resultsArray.forEach((result, index) => {
+        const address = addresses[index];
+        if (result.result) {
+          const wei = BigInt(result.result);
+          newBalances[address.toLowerCase()] = ethers.formatEther(wei);
+        } else {
+          newBalances[address.toLowerCase()] = '0';
+        }
+      });
+
+      setBalances(newBalances);
+    } catch (err) {
+      console.error('[useBalances] Failed to fetch balances:', err);
+      setError(err instanceof Error ? err.message : 'Failed to fetch balances');
+
+      // Set all balances to '0' on error
+      const fallbackBalances: BalanceMap = {};
+      addresses.forEach(addr => {
+        fallbackBalances[addr.toLowerCase()] = '0';
+      });
+      setBalances(fallbackBalances);
+    } finally {
+      setLoading(false);
+    }
+  }, [addresses, targetChain, getRpcUrl]);
+
+  // Refetch when addresses, chain, or RPC URL changes
+  useEffect(() => {
+    const addressKey = addresses.map(a => a.toLowerCase()).sort().join(',');
+    const shouldRefetch =
+      addressKey !== prevAddressesRef.current ||
+      rpcUrl !== prevRpcUrlRef.current;
+
+    if (shouldRefetch && addresses.length > 0) {
+      prevAddressesRef.current = addressKey;
+      prevRpcUrlRef.current = rpcUrl;
+      fetchBalances();
+    }
+  }, [addresses, rpcUrl, fetchBalances]);
+
+  return {
+    balances,
+    loading,
+    error,
+    refetch: fetchBalances,
+  };
+}
+
+/**
+ * Helper to get balance for a specific address from the balances map
+ */
+export function getBalance(balances: BalanceMap, address: string): string {
+  return balances[address.toLowerCase()] || '0';
+}

package/src/hooks/useTheme.ts

@@ -0,0 +1,156 @@
+'use client';
+
+import {
+  createElement,
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+  type ReactNode,
+} from 'react';
+
+export type ColorMode = 'light' | 'dark';
+export type UiScale = 'normal' | 'big';
+export type AuraTheme = 'default' | 'dark' | 'big';
+
+const LEGACY_THEME_STORAGE_KEY = 'aura-theme';
+const THEME_PREFS_STORAGE_KEY = 'vault-theme-preferences';
+const DEFAULT_THEME_PREFS: { colorMode: ColorMode; uiScale: UiScale } = {
+  colorMode: 'light',
+  uiScale: 'normal',
+};
+
+interface ThemeContextValue {
+  colorMode: ColorMode;
+  uiScale: UiScale;
+  setColorMode: (mode: ColorMode) => void;
+  setUiScale: (scale: UiScale) => void;
+  // Back-compat shim for existing callers/tests
+  theme: AuraTheme;
+  setTheme: (theme: AuraTheme) => void;
+}
+
+const ThemeContext = createContext<ThemeContextValue | null>(null);
+
+function normalizeTheme(theme: AuraTheme): { colorMode: ColorMode; uiScale: UiScale } {
+  if (theme === 'dark') return { colorMode: 'dark', uiScale: 'normal' };
+  if (theme === 'big') return { colorMode: 'light', uiScale: 'big' };
+  return { colorMode: 'light', uiScale: 'normal' };
+}
+
+function toLegacyTheme(colorMode: ColorMode, uiScale: UiScale): AuraTheme {
+  if (uiScale === 'big') return 'big';
+  return colorMode === 'dark' ? 'dark' : 'default';
+}
+
+function readStoredPrefs(): { colorMode: ColorMode; uiScale: UiScale } {
+  if (typeof window === 'undefined') return DEFAULT_THEME_PREFS;
+
+  try {
+    const rawPrefs = window.localStorage.getItem(THEME_PREFS_STORAGE_KEY);
+    if (rawPrefs) {
+      const parsed = JSON.parse(rawPrefs) as { colorMode?: string; uiScale?: string };
+      const colorMode: ColorMode = parsed.colorMode === 'dark' ? 'dark' : 'light';
+      const uiScale: UiScale = parsed.uiScale === 'big' ? 'big' : 'normal';
+      return { colorMode, uiScale };
+    }
+  } catch {
+    // ignore malformed local state
+  }
+
+  const legacyTheme = window.localStorage.getItem(LEGACY_THEME_STORAGE_KEY) as AuraTheme | null;
+  return normalizeTheme(legacyTheme === 'dark' || legacyTheme === 'big' ? legacyTheme : 'default');
+}
+
+function applyThemeAttributes(colorMode: ColorMode, uiScale: UiScale): void {
+  if (typeof document === 'undefined') return;
+  const root = document.documentElement;
+
+  if (colorMode === 'dark') root.setAttribute('data-theme', 'dark');
+  else root.removeAttribute('data-theme');
+
+  root.setAttribute('data-ui-scale', uiScale);
+
+  const scale = uiScale === 'big' ? 1.25 : 1;
+  root.style.setProperty('--ui-scale-factor', String(scale));
+
+  root.style.setProperty('--font-size-xs', `${Math.round(10 * scale)}px`);
+  root.style.setProperty('--font-size-sm', `${Math.round(12 * scale)}px`);
+  root.style.setProperty('--font-size-md', `${Math.round(14 * scale)}px`);
+  root.style.setProperty('--font-size-lg', `${Math.round(18 * scale)}px`);
+
+  root.style.setProperty('--space-1', `${Math.round(4 * scale)}px`);
+  root.style.setProperty('--space-2', `${Math.round(8 * scale)}px`);
+  root.style.setProperty('--space-3', `${Math.round(12 * scale)}px`);
+  root.style.setProperty('--space-4', `${Math.round(16 * scale)}px`);
+  root.style.setProperty('--space-6', `${Math.round(24 * scale)}px`);
+
+  root.style.setProperty('--radius-sm', `${Math.round(6 * scale)}px`);
+  root.style.setProperty('--radius-md', `${Math.round(10 * scale)}px`);
+  root.style.setProperty('--radius-lg', `${Math.round(14 * scale)}px`);
+  root.style.setProperty('--shadow-sm', uiScale === 'big' ? '0 2px 4px rgba(0,0,0,0.15)' : '0 1px 2px rgba(0,0,0,0.12)');
+  root.style.setProperty('--shadow-md', uiScale === 'big' ? '0 8px 20px rgba(0,0,0,0.24)' : '0 6px 16px rgba(0,0,0,0.18)');
+
+  root.style.setProperty('--control-height-sm', `${Math.round(32 * scale)}px`);
+  root.style.setProperty('--control-height-md', `${Math.round(36 * scale)}px`);
+  root.style.setProperty('--control-height-lg', `${Math.round(40 * scale)}px`);
+
+  // keep existing aliases used around the codebase
+  root.style.setProperty('--space-xs', `var(--space-1)`);
+  root.style.setProperty('--space-sm', `var(--space-2)`);
+  root.style.setProperty('--space-md', `var(--space-3)`);
+  root.style.setProperty('--space-lg', `var(--space-4)`);
+}
+
+export function ThemeProvider({ children }: { children: ReactNode }) {
+  const [colorMode, setColorModeState] = useState<ColorMode>(DEFAULT_THEME_PREFS.colorMode);
+  const [uiScale, setUiScaleState] = useState<UiScale>(DEFAULT_THEME_PREFS.uiScale);
+  const [hasHydratedPrefs, setHasHydratedPrefs] = useState(false);
+
+  useEffect(() => {
+    const stored = readStoredPrefs();
+    setColorModeState(stored.colorMode);
+    setUiScaleState(stored.uiScale);
+    setHasHydratedPrefs(true);
+    applyThemeAttributes(stored.colorMode, stored.uiScale);
+  }, []);
+
+  useEffect(() => {
+    if (!hasHydratedPrefs) return;
+    applyThemeAttributes(colorMode, uiScale);
+    if (typeof window === 'undefined') return;
+    window.localStorage.setItem(THEME_PREFS_STORAGE_KEY, JSON.stringify({ colorMode, uiScale }));
+    const legacy = toLegacyTheme(colorMode, uiScale);
+    if (legacy === 'default') window.localStorage.removeItem(LEGACY_THEME_STORAGE_KEY);
+    else window.localStorage.setItem(LEGACY_THEME_STORAGE_KEY, legacy);
+  }, [hasHydratedPrefs, colorMode, uiScale]);
+
+  const setColorMode = useCallback((mode: ColorMode) => setColorModeState(mode), []);
+  const setUiScale = useCallback((scale: UiScale) => setUiScaleState(scale), []);
+  const setTheme = useCallback((theme: AuraTheme) => {
+    const parsed = normalizeTheme(theme);
+    setColorModeState(parsed.colorMode);
+    setUiScaleState(parsed.uiScale);
+  }, []);
+
+  const theme = useMemo(() => toLegacyTheme(colorMode, uiScale), [colorMode, uiScale]);
+
+  const value = useMemo<ThemeContextValue>(() => ({
+    colorMode,
+    uiScale,
+    setColorMode,
+    setUiScale,
+    theme,
+    setTheme,
+  }), [colorMode, uiScale, setColorMode, setUiScale, theme, setTheme]);
+
+  return createElement(ThemeContext.Provider, { value }, children);
+}
+
+export function useTheme(): ThemeContextValue {
+  const context = useContext(ThemeContext);
+  if (!context) throw new Error('useTheme must be used within a ThemeProvider');
+  return context;
+}

package/src/instrumentation.ts

@@ -0,0 +1,12 @@
+/**
+ * Next.js instrumentation hook
+ * Sets up WebSocket server for real-time events
+ */
+
+export async function register() {
+  // Only run on server
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { setupWebSocketServer } = await import('./lib/websocket-setup');
+    setupWebSocketServer();
+  }
+}

package/src/lib/api-docs.ts

@@ -0,0 +1,154 @@
+import 'server-only';
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const DOCS_DIR = path.join(process.cwd(), 'docs');
+export const API_ENTRY_DOC = 'API.md';
+
+interface ApiDocGroupConfig {
+  label: string;
+  collapsible?: boolean;
+  filenames: string[];
+}
+
+const API_DOC_GROUP_CONFIG: ApiDocGroupConfig[] = [
+  {
+    label: 'GETTING STARTED',
+    collapsible: false,
+    filenames: [
+      'API.md',
+      'api/authentication.md',
+    ],
+  },
+  {
+    label: 'SECRETS',
+    filenames: [
+      'api/secrets/credentials.md',
+      'api/secrets/sharing.md',
+      'api/secrets/api-keys.md',
+    ],
+  },
+  {
+    label: 'WALLETS',
+    filenames: [
+      'api/wallets/core.md',
+      'api/wallets/data-portfolio.md',
+      'api/wallets/apps-strategies.md',
+    ],
+  },
+  {
+    label: 'SYSTEM',
+    filenames: [
+      'api/system.md',
+    ],
+  },
+];
+
+const stripMarkdown = (value: string) => value.replace(/[`*_]/g, '').trim();
+
+const normalizeDocPath = (value: string): string =>
+  path.posix.normalize(value.replace(/\\/g, '/').replace(/^\/+/, ''));
+
+const safeDecodeURIComponent = (value: string): string => {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+};
+
+const parseSummary = (content: string): string => {
+  const lines = content.split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.startsWith('#')) continue;
+    if (line.startsWith('```')) continue;
+    if (line.startsWith('|')) continue;
+    if (line === '---') continue;
+    return stripMarkdown(line);
+  }
+  return 'No summary available.';
+};
+
+const parseTitle = (filename: string, content: string): string => {
+  const headingMatch = content.match(/^#\s+(.+)$/m);
+  if (headingMatch) return stripMarkdown(headingMatch[1]);
+  return path.basename(filename).replace(/\.md$/i, '').toUpperCase();
+};
+
+const API_DOC_FILENAMES = [...new Set(API_DOC_GROUP_CONFIG.flatMap((group) => group.filenames))];
+const API_DOC_FILENAME_SET = new Set(API_DOC_FILENAMES);
+
+export interface ApiDocFile {
+  filename: string;
+  title: string;
+  summary: string;
+}
+
+export interface ApiDocGroup {
+  label: string;
+  collapsible: boolean;
+  docs: ApiDocFile[];
+}
+
+const readApiDocMeta = async (filename: string): Promise<ApiDocFile> => {
+  const content = await readApiDocFile(filename);
+  return {
+    filename,
+    title: parseTitle(filename, content),
+    summary: parseSummary(content),
+  };
+};
+
+export const listApiDocGroups = async (): Promise<ApiDocGroup[]> => {
+  const groups = await Promise.all(API_DOC_GROUP_CONFIG.map(async (group) => ({
+    label: group.label,
+    collapsible: group.collapsible ?? true,
+    docs: await Promise.all(group.filenames.map((filename) => readApiDocMeta(filename))),
+  })));
+
+  return groups;
+};
+
+export const listApiDocFiles = async (): Promise<ApiDocFile[]> => {
+  const groups = await listApiDocGroups();
+  return groups.flatMap((group) => group.docs);
+};
+
+export const normalizeApiDocFilename = (value?: string | null): string => {
+  const raw = (value || API_ENTRY_DOC).trim();
+  const normalized = normalizeDocPath(safeDecodeURIComponent(raw).replace(/^\.\/?/, '').replace(/^docs\//i, ''));
+  if (!normalized || normalized === '.') return API_ENTRY_DOC;
+  return normalized;
+};
+
+export const parseApiDocFilenameFromRouteSegments = (segments: string[]): string =>
+  normalizeApiDocFilename((segments || []).map((segment) => safeDecodeURIComponent(segment)).join('/'));
+
+export const getApiDocHref = (filename: string): string => {
+  const normalized = normalizeApiDocFilename(filename);
+  if (normalized === API_ENTRY_DOC) return '/api';
+  const encoded = normalized.split('/').map((segment) => encodeURIComponent(segment)).join('/');
+  return `/api/${encoded}`;
+};
+
+export const readApiDocFile = async (filename: string): Promise<string> => {
+  const normalized = normalizeApiDocFilename(filename);
+  if (!normalized.toLowerCase().endsWith('.md')) {
+    throw new Error(`Invalid API doc file: ${filename}`);
+  }
+  if (!API_DOC_FILENAME_SET.has(normalized)) {
+    throw new Error(`Unknown API doc file: ${filename}`);
+  }
+  if (normalized.startsWith('../') || normalized === '..') {
+    throw new Error('Path traversal attempt blocked');
+  }
+
+  const fullPath = path.join(DOCS_DIR, normalized);
+  if (!fullPath.startsWith(DOCS_DIR)) {
+    throw new Error('Path traversal attempt blocked');
+  }
+  return fs.readFile(fullPath, 'utf8');
+};