@one_deploy/sdk 1.0.7 → 1.2.0

package/src/hooks/useAITrading.ts

@@ -442,3 +442,193 @@ export function useAITrading(): UseAITradingResult {
     error,
   };
 }
+
+// ============================================
+// AI Agents Hooks
+// ============================================
+
+export interface AIAgent {
+  id: string;
+  name: string;
+  name_zh: string;
+  description: string;
+  description_zh: string;
+  category: string;
+  risk_level: number;
+  icon: string;
+  color: string;
+  tiers: Array<{ tier: number; amount: number; label: string; label_zh: string }>;
+  supported_cycles: number[];
+  default_cycle: number;
+  supported_pairs: string[];
+  supported_chains: string[];
+  is_active: boolean;
+  preview?: {
+    tier: { tier: number; amount: number; label: string };
+    cycle: number;
+    dailyLots: number;
+    stabilityScore: number;
+    roiRange: { min: number; max: number; userMin: number; userMax: number };
+    shareRate: number;
+    profitEstimate: { monthlyMin: number; monthlyMax: number; cycleMin: number; cycleMax: number };
+  };
+}
+
+export interface AIAgentParams {
+  dailyLots: number;
+  effectiveCapital: number;
+  stabilityScore: number;
+  roiRange: { min: number; max: number; userMin: number; userMax: number };
+  shareRate: number;
+  profitEstimate: { monthlyMin: number; monthlyMax: number; cycleMin: number; cycleMax: number };
+}
+
+export interface UseAIAgentsResult {
+  agents: AIAgent[];
+  shareRates: Record<number, number>;
+  isLoading: boolean;
+  error: string | null;
+  refresh: () => Promise<void>;
+}
+
+/**
+ * Hook to fetch all AI agents with their configurations
+ */
+export function useAIAgents(includeInactive = false): UseAIAgentsResult {
+  const [agents, setAgents] = useState<AIAgent[]>([]);
+  const [shareRates, setShareRates] = useState<Record<number, number>>({});
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchAgents = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await getClient().getAgentConfigs({ includeInactive });
+      if (result.success && result.data) {
+        setAgents(result.data.agents || []);
+        setShareRates(result.data.shareRates || {});
+      } else {
+        setError(result.error?.message || 'Failed to fetch agents');
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Unknown error');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [includeInactive]);
+
+  useEffect(() => {
+    fetchAgents();
+  }, [fetchAgents]);
+
+  return { agents, shareRates, isLoading, error, refresh: fetchAgents };
+}
+
+export interface UseAIAgentResult {
+  agent: AIAgent | null;
+  params: AIAgentParams | null;
+  isLoading: boolean;
+  error: string | null;
+  refresh: () => Promise<void>;
+  calculateParams: (amount: number, cycleDays: number) => Promise<AIAgentParams | null>;
+}
+
+/**
+ * Hook to fetch a single AI agent with detailed parameters
+ */
+export function useAIAgent(agentId: string | undefined): UseAIAgentResult {
+  const [agent, setAgent] = useState<AIAgent | null>(null);
+  const [params, setParams] = useState<AIAgentParams | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchAgent = useCallback(async () => {
+    if (!agentId) {
+      setIsLoading(false);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await getClient().getAgentConfigs({ agentId });
+      if (result.success && result.data?.agent) {
+        setAgent(result.data.agent);
+      } else {
+        setError(result.error?.message || 'Agent not found');
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Unknown error');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [agentId]);
+
+  useEffect(() => {
+    fetchAgent();
+  }, [fetchAgent]);
+
+  const calculateParams = useCallback(async (amount: number, cycleDays: number): Promise<AIAgentParams | null> => {
+    if (!agentId) return null;
+
+    try {
+      const result = await getClient().calculateAgentParams({ agentId, amount, cycleDays });
+      if (result.success && result.data) {
+        setParams(result.data);
+        return result.data;
+      }
+      return null;
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to calculate params');
+      return null;
+    }
+  }, [agentId]);
+
+  return { agent, params, isLoading, error, refresh: fetchAgent, calculateParams };
+}
+
+export interface UseAIAgentSubscriptionResult {
+  subscribe: (agentId: string, amount: number, cycleDays: number, txHash?: string) => Promise<ApiResponse<{ order: AIOrder }>>;
+  isLoading: boolean;
+  error: string | null;
+}
+
+/**
+ * Hook to subscribe to an AI agent strategy
+ */
+export function useAIAgentSubscription(): UseAIAgentSubscriptionResult {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const subscribe = useCallback(async (
+    agentId: string,
+    amount: number,
+    cycleDays: number,
+    txHash?: string
+  ): Promise<ApiResponse<{ order: AIOrder }>> => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      // Create order for the agent strategy
+      const result = await getClient().createAIOrder({
+        strategyId: agentId,
+        amount,
+        lockPeriodDays: cycleDays,
+        txHashDeposit: txHash,
+      });
+      if (!result.success) {
+        setError(result.error?.message || 'Failed to subscribe');
+      }
+      return result;
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : 'Subscription failed';
+      setError(errorMsg);
+      return { success: false, error: { code: 'SUBSCRIPTION_ERROR', message: errorMsg } };
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  return { subscribe, isLoading, error };
+}

package/src/hooks/useBotSimulation.ts

@@ -0,0 +1,201 @@
+/**
+ * ONE SDK - Bot Simulation Hook
+ * Provides React hook for subscribing to BotSimulationEngine events
+ */
+
+import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+import type { BotLogEntry, BotState, StrategyPersonality } from '../services/forex/BotSimulationEngine';
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+export interface UseBotSimulationOptions {
+  maxLogs?: number;
+  strategyIds?: string[];
+  userPairs?: string[];
+  userChains?: string[];
+  autoStart?: boolean;
+}
+
+export interface UseBotSimulationResult {
+  /** All log entries from all strategies */
+  logs: BotLogEntry[];
+  /** Logs grouped by strategy ID */
+  logsByStrategy: Map<string, BotLogEntry[]>;
+  /** Current state for each strategy */
+  botStates: Map<string, BotState>;
+  /** Whether simulation is currently running */
+  isRunning: boolean;
+  /** Available strategies */
+  strategies: StrategyPersonality[];
+  /** Start the simulation */
+  start: (strategyIds?: string[], userPairs?: string[], userChains?: string[]) => void;
+  /** Stop the simulation */
+  stop: (strategyIds?: string[]) => void;
+  /** Clear all logs */
+  clearLogs: () => void;
+  /** Emit boot sequence messages */
+  emitBootSequence: () => void;
+  /** Get state for a specific strategy */
+  getBotState: (strategyId: string) => BotState | undefined;
+}
+
+// ── Hook Implementation ───────────────────────────────────────────────────────
+
+export function useBotSimulation(options?: UseBotSimulationOptions): UseBotSimulationResult {
+  const maxLogs = options?.maxLogs ?? 500;
+  const [logs, setLogs] = useState<BotLogEntry[]>([]);
+  const [isRunning, setIsRunning] = useState(false);
+  const [strategies, setStrategies] = useState<StrategyPersonality[]>([]);
+  const [botStatesMap, setBotStatesMap] = useState<Map<string, BotState>>(new Map());
+  const engineRef = useRef<any>(null);
+  const unsubRef = useRef<(() => void) | null>(null);
+
+  // Lazy load the engine
+  const getEngine = useCallback(() => {
+    if (!engineRef.current) {
+      try {
+        const { botSimulationEngine } = require('../services/forex/BotSimulationEngine');
+        engineRef.current = botSimulationEngine;
+        setStrategies(botSimulationEngine.getStrategies());
+      } catch {
+        // Engine not available
+      }
+    }
+    return engineRef.current;
+  }, []);
+
+  // Group logs by strategy
+  const logsByStrategy = useMemo(() => {
+    const grouped = new Map<string, BotLogEntry[]>();
+    for (const log of logs) {
+      const existing = grouped.get(log.strategyId) || [];
+      grouped.set(log.strategyId, [...existing, log]);
+    }
+    return grouped;
+  }, [logs]);
+
+  // Start simulation
+  const start = useCallback((
+    strategyIds?: string[],
+    userPairs?: string[],
+    userChains?: string[]
+  ) => {
+    const engine = getEngine();
+    if (!engine) return;
+
+    const ids = strategyIds || options?.strategyIds;
+    const pairs = userPairs || options?.userPairs;
+    const chains = userChains || options?.userChains;
+
+    if (!engine.isRunning()) {
+      engine.start(ids, pairs, chains);
+    }
+    setIsRunning(true);
+  }, [getEngine, options?.strategyIds, options?.userPairs, options?.userChains]);
+
+  // Stop simulation
+  const stop = useCallback((strategyIds?: string[]) => {
+    const engine = getEngine();
+    if (engine) {
+      engine.stop(strategyIds);
+      if (!strategyIds) {
+        setIsRunning(false);
+      }
+    }
+  }, [getEngine]);
+
+  // Clear logs
+  const clearLogs = useCallback(() => {
+    setLogs([]);
+  }, []);
+
+  // Emit boot sequence
+  const emitBootSequence = useCallback(() => {
+    const engine = getEngine();
+    if (engine) {
+      engine.emitBootSequence();
+    }
+  }, [getEngine]);
+
+  // Get state for specific strategy
+  const getBotState = useCallback((strategyId: string): BotState | undefined => {
+    return botStatesMap.get(strategyId);
+  }, [botStatesMap]);
+
+  // Subscribe to engine events
+  useEffect(() => {
+    const engine = getEngine();
+    if (!engine) return;
+
+    // Check if already running
+    setIsRunning(engine.isRunning());
+
+    // Subscribe to log events
+    unsubRef.current = engine.onLog((entry: BotLogEntry) => {
+      setLogs(prev => {
+        const next = [...prev, entry];
+        return next.length > maxLogs ? next.slice(-maxLogs) : next;
+      });
+
+      // Update bot states
+      const state = engine.getBotState(entry.strategyId);
+      if (state) {
+        setBotStatesMap(prev => {
+          const next = new Map(prev);
+          next.set(entry.strategyId, state);
+          return next;
+        });
+      }
+    });
+
+    return () => {
+      if (unsubRef.current) {
+        unsubRef.current();
+        unsubRef.current = null;
+      }
+    };
+  }, [getEngine, maxLogs]);
+
+  // Auto-start if configured
+  useEffect(() => {
+    if (options?.autoStart) {
+      const engine = getEngine();
+      if (engine && !engine.isRunning()) {
+        emitBootSequence();
+        setTimeout(() => {
+          start();
+        }, 5500); // After boot sequence completes
+      }
+    }
+  }, [options?.autoStart, getEngine, emitBootSequence, start]);
+
+  // Periodically update bot states
+  useEffect(() => {
+    if (!isRunning) return;
+
+    const interval = setInterval(() => {
+      const engine = getEngine();
+      if (engine) {
+        const states = engine.getAllBotStates();
+        if (states.size > 0) {
+          setBotStatesMap(new Map(states));
+        }
+      }
+    }, 1000);
+
+    return () => clearInterval(interval);
+  }, [isRunning, getEngine]);
+
+  return {
+    logs,
+    logsByStrategy,
+    botStates: botStatesMap,
+    isRunning,
+    strategies,
+    start,
+    stop,
+    clearLogs,
+    emitBootSequence,
+    getBotState,
+  };
+}