auramaxx 1.0.0-alpha.4

package/src/hooks/useAgentActions.ts

@@ -0,0 +1,368 @@
+'use client';
+
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { useWebSocket } from '@/context/WebSocketContext';
+import { WALLET_EVENTS, type WalletEvent, type TokenCreatedData, type TokenRevokedData, type TokenSpentData, type ActionCreatedData, type ActionResolvedData } from '@/lib/events';
+import { api, Api } from '@/lib/api';
+
+export interface HumanAction {
+  id: string;
+  type: string;
+  fromTier: string;
+  toAddress: string | null;
+  amount: string | null;
+  chain: string;
+  status: string;
+  createdAt: string;
+  metadata?: string;
+}
+
+export interface AgentToken {
+  tokenHash: string;
+  agentId: string;
+  limit: number;
+  spent: number;
+  remaining: number;
+  permissions: string[];
+  expiresAt: number;
+  isExpired: boolean;
+  isRevoked: boolean;
+  isActive: boolean; // true = valid in memory, false = DB record only (server restarted)
+  isAdmin?: boolean; // true = admin token (UI session token)
+}
+
+interface DashboardData {
+  requests: HumanAction[];
+  tokens: {
+    active: AgentToken[];
+    inactive: AgentToken[];
+  };
+  counts: {
+    pendingActions: number;
+    activeTokens: number;
+    inactiveTokens: number;
+  };
+}
+
+interface UseAgentActionsOptions {
+  autoFetch?: boolean;
+}
+
+interface ApprovalResult {
+  success: boolean;
+  token?: string;
+  agentId?: string;
+  limit?: number;
+  permissions?: string[];
+  expiresIn?: number;
+  txHash?: string;
+  message?: string;
+}
+
+interface UseAgentActionsReturn {
+  requests: HumanAction[];
+  notifications: HumanAction[];
+  dismissNotification: (id: string) => void;
+  activeTokens: AgentToken[];
+  inactiveTokens: AgentToken[];
+  loading: boolean;
+  error: string | null;
+  counts: {
+    pendingActions: number;
+    activeTokens: number;
+  };
+  refresh: () => Promise<void>;
+  resolveAction: (id: string, approved: boolean) => Promise<ApprovalResult>;
+  revokeToken: (tokenHash: string) => Promise<boolean>;
+  actionLoading: string | null;
+  lastApprovalResult: ApprovalResult | null;
+  clearApprovalResult: () => void;
+  connected: boolean;
+}
+
+export function useAgentActions(options: UseAgentActionsOptions = {}): UseAgentActionsReturn {
+  const { autoFetch = true } = options;
+
+  const [requests, setRequests] = useState<HumanAction[]>([]);
+  const [notifications, setNotifications] = useState<HumanAction[]>([]);
+  const [activeTokens, setActiveTokens] = useState<AgentToken[]>([]);
+  const [inactiveTokens, setInactiveTokens] = useState<AgentToken[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [actionLoading, setActionLoading] = useState<string | null>(null);
+  const [counts, setCounts] = useState({ pendingActions: 0, activeTokens: 0 });
+  const [lastApprovalResult, setLastApprovalResult] = useState<ApprovalResult | null>(null);
+
+  const { subscribe, connected } = useWebSocket();
+  const mountedRef = useRef(true);
+
+  const clearApprovalResult = useCallback(() => {
+    setLastApprovalResult(null);
+  }, []);
+
+  const dismissNotification = useCallback((id: string) => {
+    setNotifications(prev => prev.filter(n => n.id !== id));
+  }, []);
+
+  const fetchDashboard = useCallback(async () => {
+    try {
+      const data = await api.get<{ success: boolean; error?: string } & DashboardData>(Api.AgentDashboard, '/agent-requests');
+
+      if (!mountedRef.current) return;
+
+      if (data.success) {
+        setRequests(data.requests || []);
+        setActiveTokens(data.tokens?.active || []);
+        setInactiveTokens(data.tokens?.inactive || []);
+        setCounts({
+          pendingActions: data.counts?.pendingActions || 0,
+          activeTokens: data.counts?.activeTokens || 0,
+        });
+        setError(null);
+      } else {
+        setError(data.error || 'Failed to fetch dashboard');
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err.message : 'Failed to fetch dashboard');
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, []);
+
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    await fetchDashboard();
+  }, [fetchDashboard]);
+
+  const resolveAction = useCallback(async (id: string, approved: boolean): Promise<ApprovalResult> => {
+    setActionLoading(`resolve-${id}`);
+    try {
+      const data = await api.post<{
+        success: boolean;
+        error?: string;
+        token?: string;
+        agentId?: string;
+        limit?: number;
+        permissions?: string[];
+        expiresIn?: number;
+        txHash?: string;
+        message?: string;
+      }>(Api.Wallet, `/actions/${id}/resolve`, { approved });
+
+      if (data.success) {
+        const result: ApprovalResult = {
+          success: true,
+          token: data.token,
+          agentId: data.agentId,
+          limit: data.limit,
+          permissions: data.permissions,
+          expiresIn: data.expiresIn,
+          txHash: data.txHash,
+          message: data.message,
+        };
+        // Set lastApprovalResult when a token is returned
+        if (data.token) {
+          setLastApprovalResult(result);
+        }
+        await refresh();
+        return result;
+      } else {
+        setError(data.error || 'Action resolution failed');
+        return { success: false, message: data.error };
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Action resolution failed';
+      setError(message);
+      return { success: false, message };
+    } finally {
+      setActionLoading(null);
+    }
+  }, [refresh]);
+
+  const revokeToken = useCallback(async (tokenHash: string): Promise<boolean> => {
+    setActionLoading(`revoke-${tokenHash}`);
+    try {
+      const data = await api.post<{ success: boolean; error?: string }>(Api.Wallet, '/actions/tokens/revoke', { tokenHash });
+
+      if (data.success) {
+        // WebSocket will update the UI, but refresh as fallback
+        await refresh();
+        return true;
+      } else {
+        setError(data.error || 'Revoke failed');
+        return false;
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Revoke failed');
+      return false;
+    } finally {
+      setActionLoading(null);
+    }
+  }, [refresh]);
+
+  // Initial fetch
+  useEffect(() => {
+    mountedRef.current = true;
+    if (autoFetch) {
+      refresh();
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [autoFetch, refresh]);
+
+  // Subscribe to WebSocket events
+  useEffect(() => {
+    // Token created - add to active tokens
+    const unsubTokenCreated = subscribe(WALLET_EVENTS.TOKEN_CREATED, (event) => {
+      const data = (event as WalletEvent).data as TokenCreatedData;
+      setActiveTokens((prev) => {
+        // Check if already exists
+        if (prev.some((t) => t.tokenHash === data.tokenHash)) return prev;
+        return [
+          {
+            tokenHash: data.tokenHash,
+            agentId: data.agentId,
+            limit: data.limit,
+            spent: 0,
+            remaining: data.limit,
+            permissions: data.permissions,
+            expiresAt: data.expiresAt,
+            isExpired: false,
+            isRevoked: false,
+            isActive: true,
+          },
+          ...prev,
+        ];
+      });
+      setCounts((prev) => ({ ...prev, activeTokens: prev.activeTokens + 1 }));
+    });
+
+    // Token revoked - move from active to inactive
+    const unsubTokenRevoked = subscribe(WALLET_EVENTS.TOKEN_REVOKED, (event) => {
+      const data = (event as WalletEvent).data as TokenRevokedData;
+      setActiveTokens((prev) => {
+        const token = prev.find((t) => t.tokenHash === data.tokenHash);
+        if (token) {
+          // Move to inactive
+          setInactiveTokens((inactive) => [
+            { ...token, isRevoked: true, isActive: false },
+            ...inactive,
+          ]);
+        }
+        return prev.filter((t) => t.tokenHash !== data.tokenHash);
+      });
+      setCounts((prev) => ({
+        ...prev,
+        activeTokens: Math.max(0, prev.activeTokens - 1),
+      }));
+    });
+
+    // Token spent - update spent/remaining
+    const unsubTokenSpent = subscribe(WALLET_EVENTS.TOKEN_SPENT, (event) => {
+      const data = (event as WalletEvent).data as TokenSpentData;
+      setActiveTokens((prev) =>
+        prev.map((t) =>
+          t.tokenHash === data.tokenHash
+            ? { ...t, spent: data.newSpent, remaining: data.remaining }
+            : t
+        )
+      );
+    });
+
+    // Action created - route notify types to notifications, others to pending requests
+    const unsubActionCreated = subscribe(WALLET_EVENTS.ACTION_CREATED, (event) => {
+      const data = (event as WalletEvent).data as ActionCreatedData;
+
+      // Notify actions go to the notifications list, not pending requests
+      if (data.type === 'notify') {
+        setNotifications((prev) => {
+          if (prev.some((n) => n.id === data.id)) return prev;
+          return [
+            {
+              id: data.id,
+              type: data.type,
+              fromTier: 'system',
+              toAddress: null,
+              amount: null,
+              chain: 'base',
+              status: 'acknowledged',
+              createdAt: new Date().toISOString(),
+              metadata: JSON.stringify({
+                ...data.metadata,
+                source: data.source,
+                summary: data.summary,
+              }),
+            },
+            ...prev,
+          ];
+        });
+        return;
+      }
+
+      setRequests((prev) => {
+        if (prev.some((r) => r.id === data.id)) return prev;
+        return [
+          {
+            id: data.id,
+            type: data.type,
+            fromTier: 'system',
+            toAddress: null,
+            amount: null,
+            chain: 'base',
+            status: 'pending',
+            createdAt: new Date().toISOString(),
+            metadata: JSON.stringify({
+              ...data.metadata,
+              source: data.source,
+              summary: data.summary,
+              expiresAt: data.expiresAt,
+            }),
+          },
+          ...prev,
+        ];
+      });
+      setCounts((prev) => ({ ...prev, pendingActions: prev.pendingActions + 1 }));
+    });
+
+    // Action resolved - remove from pending requests
+    const unsubActionResolved = subscribe(WALLET_EVENTS.ACTION_RESOLVED, (event) => {
+      const data = (event as WalletEvent).data as ActionResolvedData;
+      setRequests((prev) => prev.filter((r) => r.id !== data.id));
+      setCounts((prev) => ({
+        ...prev,
+        pendingActions: Math.max(0, prev.pendingActions - 1),
+      }));
+    });
+
+    return () => {
+      unsubTokenCreated();
+      unsubTokenRevoked();
+      unsubTokenSpent();
+      unsubActionCreated();
+      unsubActionResolved();
+    };
+  }, [subscribe]);
+
+  return {
+    requests,
+    notifications,
+    dismissNotification,
+    activeTokens,
+    inactiveTokens,
+    loading,
+    error,
+    counts,
+    refresh,
+    resolveAction,
+    revokeToken,
+    actionLoading,
+    lastApprovalResult,
+    clearApprovalResult,
+    connected,
+  };
+}

package/src/hooks/useBalance.ts

@@ -0,0 +1,103 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { ethers } from 'ethers';
+import { Connection, PublicKey, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { useAuth } from '@/context/AuthContext';
+
+function isSolanaChain(chain: string): boolean {
+  return chain === 'solana' || chain === 'solana-devnet';
+}
+
+interface UseBalanceResult {
+  balance: string | null;
+  balanceWei: bigint | null;
+  loading: boolean;
+  error: string | null;
+  refetch: () => Promise<void>;
+  /** Native currency symbol for the chain */
+  currency: string;
+  /** Number of decimals for the native currency */
+  decimals: number;
+}
+
+export function useBalance(address: string | undefined, chain?: string): UseBalanceResult {
+  const { getRpcUrl, getConfiguredChains } = useAuth();
+  const [balance, setBalance] = useState<string | null>(null);
+  const [balanceWei, setBalanceWei] = useState<bigint | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Track previous values to detect changes
+  const prevAddressRef = useRef<string>('');
+  const prevRpcUrlRef = useRef<string>('');
+
+  const chains = getConfiguredChains();
+  const defaultChain = Object.keys(chains)[0] || 'base';
+  const targetChain = chain || defaultChain;
+
+  const isSolana = isSolanaChain(targetChain);
+  const currency = isSolana ? 'SOL' : 'ETH';
+  const decimals = isSolana ? 9 : 18;
+
+  // Get current RPC URL for comparison
+  const rpcUrl = getRpcUrl(targetChain);
+
+  const fetchBalance = useCallback(async () => {
+    if (!address) {
+      setBalance(null);
+      setBalanceWei(null);
+      return;
+    }
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const currentRpcUrl = getRpcUrl(targetChain);
+
+      if (isSolanaChain(targetChain)) {
+        // Solana balance fetch
+        const connection = new Connection(currentRpcUrl, 'confirmed');
+        const pubkey = new PublicKey(address);
+        const lamports = await connection.getBalance(pubkey);
+        setBalanceWei(BigInt(lamports));
+        setBalance((lamports / LAMPORTS_PER_SOL).toString());
+      } else {
+        // EVM balance fetch
+        const provider = new ethers.JsonRpcProvider(currentRpcUrl);
+        const wei = await provider.getBalance(address);
+        setBalanceWei(wei);
+        setBalance(ethers.formatEther(wei));
+      }
+    } catch (err) {
+      console.error('[useBalance] Failed to fetch balance:', err);
+      setError(err instanceof Error ? err.message : 'Failed to fetch balance');
+      setBalance(null);
+      setBalanceWei(null);
+    } finally {
+      setLoading(false);
+    }
+  }, [address, targetChain, getRpcUrl]);
+
+  // Refetch when address, chain, or RPC URL changes
+  useEffect(() => {
+    const shouldRefetch =
+      address !== prevAddressRef.current ||
+      rpcUrl !== prevRpcUrlRef.current;
+
+    if (shouldRefetch) {
+      prevAddressRef.current = address || '';
+      prevRpcUrlRef.current = rpcUrl;
+      fetchBalance();
+    }
+  }, [address, rpcUrl, fetchBalance]);
+
+  return {
+    balance,
+    balanceWei,
+    loading,
+    error,
+    refetch: fetchBalance,
+    currency,
+    decimals,
+  };
+}

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/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();
+  }
+}