@one_deploy/sdk 1.0.7 → 1.2.0

package/dist/hooks/index.js

@@ -2,6 +2,1687 @@
 
 var react = require('react');
 
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types/forex.ts
+var forex_exports = {};
+__export(forex_exports, {
+  FOREX_AGENT: () => FOREX_AGENT,
+  FOREX_CAPITAL_SPLIT: () => FOREX_CAPITAL_SPLIT,
+  FOREX_CURRENCY_PAIRS: () => FOREX_CURRENCY_PAIRS,
+  FOREX_CYCLE_OPTIONS: () => FOREX_CYCLE_OPTIONS,
+  FOREX_POOL_DEFAULTS: () => FOREX_POOL_DEFAULTS,
+  calculateForexNetProfit: () => calculateForexNetProfit,
+  computePoolAllocations: () => computePoolAllocations,
+  estimateForexProfit: () => estimateForexProfit
+});
+function computePoolAllocations(amount) {
+  const totalPoolReserves = amount * FOREX_CAPITAL_SPLIT.poolReserves;
+  const tradingCapital = amount * FOREX_CAPITAL_SPLIT.tradingCapital;
+  return {
+    tradingCapital,
+    totalPoolReserves,
+    clearing: totalPoolReserves * 0.5,
+    hedging: totalPoolReserves * 0.3,
+    insurance: totalPoolReserves * 0.2
+  };
+}
+function calculateForexNetProfit(grossProfit, cycleOption) {
+  const feeAmount = grossProfit * cycleOption.feeRate;
+  const postFeeProfit = grossProfit - feeAmount;
+  const netProfit = postFeeProfit * cycleOption.commissionRate;
+  return { feeAmount, postFeeProfit, netProfit };
+}
+function estimateForexProfit(amount, cycleDays, agent = FOREX_AGENT) {
+  const cycleOption = FOREX_CYCLE_OPTIONS.find((c) => c.days === cycleDays) || FOREX_CYCLE_OPTIONS[0];
+  const estimatedApy = (agent.dailyRoiMin + agent.dailyRoiMax) / 2 * 365 * 100;
+  const dailyRate = estimatedApy / 100 / 365;
+  const grossProfit = amount * dailyRate * cycleDays;
+  const { feeAmount, netProfit } = calculateForexNetProfit(grossProfit, cycleOption);
+  return { grossProfit, feeAmount, netProfit, dailyRate };
+}
+var FOREX_CAPITAL_SPLIT, FOREX_CYCLE_OPTIONS, FOREX_CURRENCY_PAIRS, FOREX_POOL_DEFAULTS, FOREX_AGENT;
+var init_forex = __esm({
+  "src/types/forex.ts"() {
+    FOREX_CAPITAL_SPLIT = {
+      poolReserves: 0.5,
+      tradingCapital: 0.5
+    };
+    FOREX_CYCLE_OPTIONS = [
+      { days: 30, feeRate: 0.1, commissionRate: 0.6, label: "30D" },
+      { days: 60, feeRate: 0.08, commissionRate: 0.7, label: "60D" },
+      { days: 90, feeRate: 0.07, commissionRate: 0.75, label: "90D" },
+      { days: 180, feeRate: 0.05, commissionRate: 0.85, label: "180D" },
+      { days: 360, feeRate: 0.03, commissionRate: 0.9, label: "360D" }
+    ];
+    FOREX_CURRENCY_PAIRS = [
+      { id: "USDC_EURC", base: "USDC", quote: "EURC", symbol: "USDC/EURC", flag: "\u{1F1EA}\u{1F1FA}", name: "Euro", basePrice: 0.923, pipSize: 1e-4, spreadPips: 1.2 },
+      { id: "USDC_GBPC", base: "USDC", quote: "GBPC", symbol: "USDC/GBPC", flag: "\u{1F1EC}\u{1F1E7}", name: "British Pound", basePrice: 0.789, pipSize: 1e-4, spreadPips: 1.5 },
+      { id: "USDC_JPYC", base: "USDC", quote: "JPYC", symbol: "USDC/JPYC", flag: "\u{1F1EF}\u{1F1F5}", name: "Japanese Yen", basePrice: 154.5, pipSize: 0.01, spreadPips: 1 },
+      { id: "USDC_AUDC", base: "USDC", quote: "AUDC", symbol: "USDC/AUDC", flag: "\u{1F1E6}\u{1F1FA}", name: "Australian Dollar", basePrice: 1.538, pipSize: 1e-4, spreadPips: 1.8 },
+      { id: "USDC_CADC", base: "USDC", quote: "CADC", symbol: "USDC/CADC", flag: "\u{1F1E8}\u{1F1E6}", name: "Canadian Dollar", basePrice: 1.364, pipSize: 1e-4, spreadPips: 1.5 },
+      { id: "USDC_CHFC", base: "USDC", quote: "CHFC", symbol: "USDC/CHFC", flag: "\u{1F1E8}\u{1F1ED}", name: "Swiss Franc", basePrice: 0.875, pipSize: 1e-4, spreadPips: 1.3 }
+    ];
+    FOREX_POOL_DEFAULTS = [
+      { id: "clearing", nameKey: "forex.pool_clearing", descriptionKey: "forex.pool_clearing_desc", allocation: 0.5, totalSize: 125e5, utilization: 0.78, color: "#3B82F6", apy7d: 12.8, apy30d: 11.5, netFlow24h: 185e3, txCount24h: 42, txCountTotal: 12840, totalDeposits: 452e5, totalWithdrawals: 327e5, profitDistributed: 185e4, lastUpdated: Date.now() },
+      { id: "hedging", nameKey: "forex.pool_hedging", descriptionKey: "forex.pool_hedging_desc", allocation: 0.3, totalSize: 75e5, utilization: 0.65, color: "#F59E0B", apy7d: 8.1, apy30d: 7.6, netFlow24h: 72e3, txCount24h: 24, txCountTotal: 7620, totalDeposits: 285e5, totalWithdrawals: 21e6, profitDistributed: 98e4, lastUpdated: Date.now() },
+      { id: "insurance", nameKey: "forex.pool_insurance", descriptionKey: "forex.pool_insurance_desc", allocation: 0.2, totalSize: 5e6, utilization: 0.42, color: "#10B981", apy7d: 4.8, apy30d: 4.5, netFlow24h: 35e3, txCount24h: 14, txCountTotal: 4280, totalDeposits: 158e5, totalWithdrawals: 108e5, profitDistributed: 52e4, lastUpdated: Date.now() }
+    ];
+    FOREX_AGENT = {
+      id: "stablefx-01",
+      nameKey: "forex.agent_name",
+      descriptionKey: "forex.agent_description",
+      icon: "\u{1F4B1}",
+      color: "#0EA5E9",
+      supportedPairs: FOREX_CURRENCY_PAIRS.map((p) => p.id),
+      dailyRoiMin: 2e-3,
+      dailyRoiMax: 5e-3,
+      totalManaged: 25e6,
+      totalUsers: 3847,
+      winRate: 72.5
+    };
+  }
+});
+
+// src/services/forex/ForexPoolDataGenerator.ts
+var ForexPoolDataGenerator_exports = {};
+__export(ForexPoolDataGenerator_exports, {
+  ForexPoolDataGenerator: () => ForexPoolDataGenerator
+});
+function rand(min, max) {
+  return min + Math.random() * (max - min);
+}
+function randInt(min, max) {
+  return Math.floor(rand(min, max + 1));
+}
+function pick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function genTxHash() {
+  const chars = "0123456789abcdef";
+  let hash = "0x";
+  for (let i = 0; i < 64; i++) hash += chars[Math.floor(Math.random() * 16)];
+  return hash;
+}
+function formatDate(d) {
+  return d.toISOString().split("T")[0];
+}
+function genId(prefix) {
+  return `${prefix}_${Date.now().toString(36)}_${(++_idCounter).toString(36)}`;
+}
+var _idCounter, POOL_PARAMS, ForexPoolDataGeneratorClass, _instance, ForexPoolDataGenerator;
+var init_ForexPoolDataGenerator = __esm({
+  "src/services/forex/ForexPoolDataGenerator.ts"() {
+    init_forex();
+    _idCounter = 0;
+    POOL_PARAMS = {
+      clearing: {
+        meanDailyPnlPct: 35e-5,
+        stddevPnlPct: 15e-5,
+        utilizationMin: 0.7,
+        utilizationMax: 0.85,
+        depositsPerDay: [15, 25],
+        withdrawalsPerDay: [8, 12],
+        profitDistPerDay: 5,
+        avgDepositSize: 25e3,
+        avgWithdrawalSize: 18e3
+      },
+      hedging: {
+        meanDailyPnlPct: 22e-5,
+        stddevPnlPct: 2e-4,
+        utilizationMin: 0.55,
+        utilizationMax: 0.75,
+        depositsPerDay: [8, 15],
+        withdrawalsPerDay: [5, 8],
+        profitDistPerDay: 3,
+        avgDepositSize: 18e3,
+        avgWithdrawalSize: 12e3
+      },
+      insurance: {
+        meanDailyPnlPct: 13e-5,
+        stddevPnlPct: 8e-5,
+        utilizationMin: 0.3,
+        utilizationMax: 0.5,
+        depositsPerDay: [5, 10],
+        withdrawalsPerDay: [3, 5],
+        profitDistPerDay: 2,
+        avgDepositSize: 12e3,
+        avgWithdrawalSize: 8e3
+      }
+    };
+    ForexPoolDataGeneratorClass = class {
+      constructor() {
+        this.snapshotCache = null;
+        this.transactionCache = null;
+        this.baseBlockNumber = 195e5;
+      }
+      // ── Public API ─────────────────────────────────────────────────────────
+      generateAllSnapshots() {
+        if (this.snapshotCache) return this.snapshotCache;
+        const result = {
+          clearing: [],
+          hedging: [],
+          insurance: []
+        };
+        for (const pool of FOREX_POOL_DEFAULTS) {
+          result[pool.id] = this.generatePoolSnapshots(pool.id, pool.totalSize);
+        }
+        this.snapshotCache = result;
+        return result;
+      }
+      generateAllTransactions() {
+        if (this.transactionCache) return this.transactionCache;
+        const allTx = [];
+        for (const pool of FOREX_POOL_DEFAULTS) {
+          const snapshots = this.snapshotCache?.[pool.id] || this.generatePoolSnapshots(pool.id, pool.totalSize);
+          const txs = this.generatePoolTransactions(pool.id, snapshots);
+          allTx.push(...txs);
+        }
+        const now = /* @__PURE__ */ new Date();
+        for (let i = 0; i < 60; i++) {
+          const day = new Date(now);
+          day.setDate(day.getDate() - (60 - i));
+          const dayOfWeek = day.getDay();
+          if (dayOfWeek === 2 || dayOfWeek === 4 || dayOfWeek === 5 && Math.random() < 0.4) {
+            const fromPool = pick(["clearing", "hedging", "insurance"]);
+            const toOptions = ["clearing", "hedging", "insurance"].filter((p) => p !== fromPool);
+            const toPool = pick(toOptions);
+            const amount = rand(5e4, 2e5);
+            const ts = day.getTime() + randInt(10, 18) * 36e5;
+            allTx.push({
+              id: genId("ipt"),
+              poolId: fromPool,
+              type: "inter_pool_transfer",
+              amount: -amount,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + i * 7200 + randInt(0, 100),
+              timestamp: ts,
+              description: `Transfer to ${toPool} pool`
+            });
+            allTx.push({
+              id: genId("ipt"),
+              poolId: toPool,
+              type: "inter_pool_transfer",
+              amount,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + i * 7200 + randInt(100, 200),
+              timestamp: ts + 5e3,
+              description: `Transfer from ${fromPool} pool`
+            });
+          }
+          if (dayOfWeek === 3 && Math.random() < 0.85) {
+            const pool = pick(FOREX_POOL_DEFAULTS);
+            const rebalanceAmt = rand(2e4, 1e5);
+            const ts = day.getTime() + randInt(2, 6) * 36e5;
+            allTx.push({
+              id: genId("rrb"),
+              poolId: pool.id,
+              type: "reserve_rebalance",
+              amount: Math.random() < 0.5 ? rebalanceAmt : -rebalanceAmt,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + i * 7200 + randInt(200, 300),
+              timestamp: ts,
+              description: "Automated reserve rebalance"
+            });
+          }
+        }
+        allTx.sort((a, b) => a.timestamp - b.timestamp);
+        const runningBalance = {
+          clearing: FOREX_POOL_DEFAULTS[0].totalSize * 0.85,
+          hedging: FOREX_POOL_DEFAULTS[1].totalSize * 0.82,
+          insurance: FOREX_POOL_DEFAULTS[2].totalSize * 0.88
+        };
+        for (const tx of allTx) {
+          tx.balanceBefore = runningBalance[tx.poolId];
+          runningBalance[tx.poolId] += tx.amount;
+          tx.balanceAfter = runningBalance[tx.poolId];
+        }
+        this.transactionCache = allTx;
+        return allTx;
+      }
+      generateTradeHistory(investmentAmount, startDate, selectedPairs) {
+        const trades = [];
+        const start = new Date(startDate);
+        const now = /* @__PURE__ */ new Date();
+        const dayCount = Math.min(60, Math.ceil((now.getTime() - start.getTime()) / 864e5));
+        let cumulativePnl = 0;
+        let blockNum = this.baseBlockNumber + randInt(0, 5e3);
+        for (let d = 0; d < dayCount; d++) {
+          const day = new Date(start);
+          day.setDate(day.getDate() + d);
+          const dayOfWeek = day.getDay();
+          const baseCount = dayOfWeek === 0 || dayOfWeek === 6 ? randInt(1, 2) : randInt(3, 8);
+          for (let t = 0; t < baseCount; t++) {
+            const pair = FOREX_CURRENCY_PAIRS.find((p) => p.id === pick(selectedPairs)) || pick(FOREX_CURRENCY_PAIRS);
+            const side = Math.random() > 0.5 ? "BUY" : "SELL";
+            const lots = parseFloat(rand(0.1, 2.5).toFixed(2));
+            const rfqPrice = pair.basePrice * (1 + rand(-3e-3, 3e-3));
+            const quoteSpread = rand(0.5, 2) * pair.pipSize;
+            const quotePrice = side === "BUY" ? rfqPrice + quoteSpread : rfqPrice - quoteSpread;
+            const matched = Math.random() < 0.85;
+            if (!matched) continue;
+            const matchPrice = quotePrice * (1 + rand(-5e-5, 5e-5));
+            const settlePrice = matchPrice * (1 + rand(-2e-5, 2e-5));
+            const pips = (settlePrice - rfqPrice) / pair.pipSize * (side === "BUY" ? 1 : -1);
+            const pnl = pips * pair.pipSize * lots * 1e5;
+            const isWin = Math.random() < FOREX_AGENT.winRate / 100;
+            const finalPnl = isWin ? Math.abs(pnl) : -Math.abs(pnl) * rand(0.3, 0.8);
+            cumulativePnl += finalPnl;
+            const clearingFee = Math.abs(finalPnl) * rand(1e-3, 3e-3);
+            const hedgingCost = Math.abs(finalPnl) * rand(5e-4, 2e-3);
+            const insuranceReserve = Math.abs(finalPnl) * rand(3e-4, 1e-3);
+            blockNum += randInt(1, 20);
+            const timestamp = day.getTime() + randInt(0, 23) * 36e5 + randInt(0, 36e5);
+            trades.push({
+              id: genId("FXT"),
+              timestamp,
+              pairId: pair.id,
+              pairSymbol: pair.symbol,
+              side,
+              rfqPrice,
+              quotePrice,
+              matchPrice,
+              settlePrice,
+              lots,
+              pips: isWin ? Math.abs(pips) : -Math.abs(pips) * rand(0.3, 0.8),
+              pnl: finalPnl,
+              status: "SETTLED",
+              pvpSettled: true,
+              clearingFee,
+              hedgingCost,
+              insuranceReserve,
+              txHash: genTxHash(),
+              blockNumber: blockNum,
+              cycleDay: d + 1,
+              cumulativePnl
+            });
+          }
+        }
+        trades.sort((a, b) => a.timestamp - b.timestamp);
+        return trades;
+      }
+      generateLiveTransaction(poolId, type, baseAmount) {
+        const params = POOL_PARAMS[poolId];
+        let amount;
+        switch (type) {
+          case "deposit":
+            amount = baseAmount ?? rand(params.avgDepositSize * 0.5, params.avgDepositSize * 1.5);
+            break;
+          case "withdrawal":
+            amount = -(baseAmount ?? rand(params.avgWithdrawalSize * 0.5, params.avgWithdrawalSize * 1.5));
+            break;
+          case "profit_distribution":
+            amount = baseAmount ?? rand(500, 5e3);
+            break;
+          case "fee_collection":
+            amount = baseAmount ?? rand(100, 2e3);
+            break;
+          case "loss_absorption":
+            amount = -(baseAmount ?? rand(200, 3e3));
+            break;
+          default:
+            amount = baseAmount ?? rand(-5e3, 5e3);
+        }
+        const pool = FOREX_POOL_DEFAULTS.find((p) => p.id === poolId);
+        const balanceBefore = pool.totalSize;
+        return {
+          id: genId("ptx"),
+          poolId,
+          type,
+          amount,
+          balanceBefore,
+          balanceAfter: balanceBefore + amount,
+          txHash: genTxHash(),
+          blockNumber: this.baseBlockNumber + Math.floor(Date.now() / 12e3),
+          timestamp: Date.now(),
+          description: this.getTxDescription(type, poolId, Math.abs(amount))
+        };
+      }
+      // ── Private Methods ────────────────────────────────────────────────────
+      generatePoolSnapshots(poolId, currentSize) {
+        const params = POOL_PARAMS[poolId];
+        const snapshots = [];
+        const now = /* @__PURE__ */ new Date();
+        let balance = currentSize * rand(0.82, 0.88);
+        let cumulativePnl = 0;
+        for (let i = 59; i >= 0; i--) {
+          const day = new Date(now);
+          day.setDate(day.getDate() - i);
+          const dayOfWeek = day.getDay();
+          const isWeekend = dayOfWeek === 0 || dayOfWeek === 6;
+          const openBalance = balance;
+          const activityMultiplier = isWeekend ? 0.2 : 1;
+          const isDrawdown = !isWeekend && Math.random() < 0.2;
+          let dailyPnlPct;
+          if (isDrawdown) {
+            dailyPnlPct = -rand(1e-4, params.stddevPnlPct * 2);
+          } else {
+            dailyPnlPct = this.gaussianRandom(params.meanDailyPnlPct, params.stddevPnlPct);
+          }
+          dailyPnlPct *= activityMultiplier;
+          const dailyPnl = balance * dailyPnlPct;
+          cumulativePnl += dailyPnl;
+          const depositCount = isWeekend ? randInt(1, Math.ceil(params.depositsPerDay[0] * 0.2)) : randInt(params.depositsPerDay[0], params.depositsPerDay[1]);
+          const withdrawalCount = isWeekend ? randInt(0, Math.ceil(params.withdrawalsPerDay[0] * 0.2)) : randInt(params.withdrawalsPerDay[0], params.withdrawalsPerDay[1]);
+          const deposits = depositCount * params.avgDepositSize * rand(0.7, 1.3) * activityMultiplier;
+          const withdrawals = withdrawalCount * params.avgWithdrawalSize * rand(0.7, 1.3) * activityMultiplier;
+          const netFlow = deposits - withdrawals;
+          balance += dailyPnl + netFlow;
+          const txCount = depositCount + withdrawalCount + Math.round(params.profitDistPerDay * activityMultiplier);
+          const utilization = rand(params.utilizationMin, params.utilizationMax);
+          const activeUsers = Math.round(rand(80, 400) * activityMultiplier);
+          snapshots.push({
+            poolId,
+            date: formatDate(day),
+            openBalance,
+            closeBalance: balance,
+            deposits,
+            withdrawals,
+            netFlow,
+            dailyPnl,
+            dailyPnlPct,
+            cumulativePnl,
+            utilization,
+            txCount,
+            activeUsers
+          });
+        }
+        return snapshots;
+      }
+      generatePoolTransactions(poolId, snapshots) {
+        const params = POOL_PARAMS[poolId];
+        const transactions = [];
+        for (const snap of snapshots) {
+          const day = new Date(snap.date);
+          const dayOfWeek = day.getDay();
+          const isWeekend = dayOfWeek === 0 || dayOfWeek === 6;
+          const mult = isWeekend ? 0.2 : 1;
+          const depositCount = Math.round(randInt(params.depositsPerDay[0], params.depositsPerDay[1]) * mult);
+          const withdrawalCount = Math.round(randInt(params.withdrawalsPerDay[0], params.withdrawalsPerDay[1]) * mult);
+          const profitCount = Math.round(params.profitDistPerDay * mult);
+          for (let i = 0; i < depositCount; i++) {
+            const amount = rand(params.avgDepositSize * 0.3, params.avgDepositSize * 2);
+            const ts = day.getTime() + randInt(0, 23) * 36e5 + randInt(0, 36e5);
+            transactions.push({
+              id: genId("dep"),
+              poolId,
+              type: "deposit",
+              amount,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + Math.floor(ts / 12e3) + randInt(0, 50),
+              timestamp: ts,
+              description: `Deposit to ${poolId} pool`
+            });
+          }
+          for (let i = 0; i < withdrawalCount; i++) {
+            const amount = rand(params.avgWithdrawalSize * 0.3, params.avgWithdrawalSize * 2);
+            const ts = day.getTime() + randInt(0, 23) * 36e5 + randInt(0, 36e5);
+            transactions.push({
+              id: genId("wdr"),
+              poolId,
+              type: "withdrawal",
+              amount: -amount,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + Math.floor(ts / 12e3) + randInt(0, 50),
+              timestamp: ts,
+              description: `Withdrawal from ${poolId} pool`
+            });
+          }
+          for (let i = 0; i < profitCount; i++) {
+            const amount = rand(500, 8e3);
+            const ts = day.getTime() + randInt(6, 22) * 36e5 + randInt(0, 36e5);
+            transactions.push({
+              id: genId("prd"),
+              poolId,
+              type: "profit_distribution",
+              amount,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + Math.floor(ts / 12e3) + randInt(0, 50),
+              timestamp: ts,
+              description: `Profit distribution from ${poolId} pool`
+            });
+          }
+          if (!isWeekend) {
+            const feeCount = randInt(1, 2);
+            for (let i = 0; i < feeCount; i++) {
+              const amount = rand(100, 3e3);
+              const ts = day.getTime() + randInt(8, 20) * 36e5;
+              transactions.push({
+                id: genId("fee"),
+                poolId,
+                type: "fee_collection",
+                amount,
+                balanceBefore: 0,
+                balanceAfter: 0,
+                txHash: genTxHash(),
+                blockNumber: this.baseBlockNumber + Math.floor(ts / 12e3) + randInt(0, 50),
+                timestamp: ts,
+                description: `Fee collection for ${poolId} pool`
+              });
+            }
+          }
+        }
+        return transactions;
+      }
+      gaussianRandom(mean, stddev) {
+        let u = 0, v = 0;
+        while (u === 0) u = Math.random();
+        while (v === 0) v = Math.random();
+        const z = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+        return mean + z * stddev;
+      }
+      getTxDescription(type, poolId, amount) {
+        const fmt = `$${amount.toLocaleString(void 0, { maximumFractionDigits: 0 })}`;
+        switch (type) {
+          case "deposit":
+            return `Deposit ${fmt} to ${poolId} pool`;
+          case "withdrawal":
+            return `Withdrawal ${fmt} from ${poolId} pool`;
+          case "profit_distribution":
+            return `Profit distribution ${fmt} from ${poolId}`;
+          case "loss_absorption":
+            return `Loss absorbed ${fmt} by ${poolId} pool`;
+          case "inter_pool_transfer":
+            return `Inter-pool transfer ${fmt}`;
+          case "fee_collection":
+            return `Fee collected ${fmt} in ${poolId}`;
+          case "reserve_rebalance":
+            return `Reserve rebalance ${fmt} in ${poolId}`;
+          default:
+            return `${type} ${fmt}`;
+        }
+      }
+    };
+    _instance = null;
+    ForexPoolDataGenerator = {
+      getInstance() {
+        if (!_instance) {
+          _instance = new ForexPoolDataGeneratorClass();
+        }
+        return _instance;
+      }
+    };
+  }
+});
+
+// src/services/forex/ForexSimulationEngine.ts
+var ForexSimulationEngine_exports = {};
+__export(ForexSimulationEngine_exports, {
+  forexSimulationEngine: () => forexSimulationEngine
+});
+function genId2() {
+  return `fxlog_${Date.now()}_${++idCounter}`;
+}
+function tradeId() {
+  return `FXT_${Date.now().toString(36).toUpperCase()}_${(++idCounter).toString(36).toUpperCase()}`;
+}
+function rand2(min, max) {
+  return min + Math.random() * (max - min);
+}
+function randInt2(min, max) {
+  return Math.floor(rand2(min, max + 1));
+}
+function pick2(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function formatRate(price, pair) {
+  if (pair.pipSize >= 0.01) return price.toFixed(3);
+  return price.toFixed(5);
+}
+var idCounter, FX_NEWS, ForexSimulationEngine, forexSimulationEngine;
+var init_ForexSimulationEngine = __esm({
+  "src/services/forex/ForexSimulationEngine.ts"() {
+    init_forex();
+    idCounter = 0;
+    FX_NEWS = [
+      "ECB signals potential rate adjustment, EUR pairs volatile",
+      "BOJ maintains yield curve control, JPY weakens further",
+      "Fed minutes reveal hawkish sentiment, USD strengthens",
+      "UK CPI data beats expectations, GBP rallies",
+      "RBA holds rates steady, AUD consolidates",
+      "SNB intervenes in currency markets, CHF stabilizes",
+      "Bank of Canada rate decision pending, CAD in focus",
+      "Cross-border stablecoin settlement volume hits $2.1B daily",
+      "Circle USDC reserves fully backed, attestation report released",
+      "DeFi forex protocol TVL reaches new high at $890M",
+      "On-chain FX liquidity deepens across major pairs",
+      "Institutional adoption of on-chain forex accelerates"
+    ];
+    ForexSimulationEngine = class {
+      constructor() {
+        this.listeners = [];
+        this.poolTxListeners = [];
+        this.cycleTimer = null;
+        this.pairStates = /* @__PURE__ */ new Map();
+        this.running = false;
+        this.openPositions = [];
+        this.totalPnl = 0;
+        this.totalTrades = 0;
+        this.totalPips = 0;
+        this.totalLots = 0;
+        for (const pair of FOREX_CURRENCY_PAIRS) {
+          const jitter = pair.basePrice * rand2(-3e-3, 3e-3);
+          const price = pair.basePrice + jitter;
+          const halfSpread = pair.spreadPips * pair.pipSize / 2;
+          this.pairStates.set(pair.id, {
+            pair,
+            currentPrice: price,
+            bidPrice: price - halfSpread,
+            askPrice: price + halfSpread,
+            lastSpread: pair.spreadPips
+          });
+        }
+      }
+      // ── Public API ─────────────────────────────────────────────────────────────
+      start() {
+        this.running = true;
+        this.scheduleCycle();
+      }
+      stop() {
+        this.running = false;
+        if (this.cycleTimer) {
+          clearTimeout(this.cycleTimer);
+          this.cycleTimer = null;
+        }
+      }
+      onLog(callback) {
+        this.listeners.push(callback);
+        return () => {
+          this.listeners = this.listeners.filter((l) => l !== callback);
+        };
+      }
+      onPoolTransaction(callback) {
+        this.poolTxListeners.push(callback);
+        return () => {
+          this.poolTxListeners = this.poolTxListeners.filter((l) => l !== callback);
+        };
+      }
+      isRunning() {
+        return this.running;
+      }
+      getStats() {
+        return {
+          totalPnl: this.totalPnl,
+          totalTrades: this.totalTrades,
+          totalPips: this.totalPips,
+          totalLots: this.totalLots,
+          positions: this.openPositions.length
+        };
+      }
+      getPairStates() {
+        return this.pairStates;
+      }
+      emitBootSequence() {
+        const bootMessages = [
+          { msg: "Initializing StableFX Engine v2.1.0...", delay: 0 },
+          { msg: "Connecting to Circle StableFX RFQ network...", delay: 500 },
+          { msg: "Loading USDC stablecoin pair feeds (6 pairs)...", delay: 1200 },
+          { msg: "Calibrating PvP settlement engine...", delay: 2e3 },
+          { msg: "Initializing clearing pool ($12.5M)...", delay: 2800 },
+          { msg: "Initializing hedging pool ($7.5M)...", delay: 3400 },
+          { msg: "Initializing insurance pool ($5.0M)...", delay: 4e3 },
+          { msg: "Risk management module online (max exposure: 25%)", delay: 4500 },
+          { msg: "=== StableFX Engine ready. Starting RFQ cycles ===", delay: 5e3 }
+        ];
+        for (const { msg, delay } of bootMessages) {
+          setTimeout(() => {
+            this.emit({
+              id: genId2(),
+              timestamp: Date.now(),
+              type: "SYSTEM",
+              message: msg,
+              importance: "medium"
+            });
+          }, delay);
+        }
+      }
+      destroy() {
+        this.stop();
+        this.listeners = [];
+        this.poolTxListeners = [];
+        this.pairStates.clear();
+        this.openPositions = [];
+      }
+      // ── Private Methods ────────────────────────────────────────────────────────
+      emit(entry) {
+        for (const listener of this.listeners) {
+          listener(entry);
+        }
+      }
+      emitPoolTx(tx) {
+        for (const listener of this.poolTxListeners) {
+          listener(tx);
+        }
+      }
+      generatePoolTxFromEvent(type, data) {
+        try {
+          const { ForexPoolDataGenerator: ForexPoolDataGenerator2 } = (init_ForexPoolDataGenerator(), __toCommonJS(ForexPoolDataGenerator_exports));
+          const generator = ForexPoolDataGenerator2.getInstance();
+          if (type === "SETTLE" && data.pnl !== void 0) {
+            const tx = generator.generateLiveTransaction("clearing", "fee_collection", Math.abs(data.pnl) * rand2(1e-3, 3e-3));
+            this.emitPoolTx(tx);
+          } else if (type === "HEDGE") {
+            const tx = generator.generateLiveTransaction("hedging", data.pnl && data.pnl < 0 ? "loss_absorption" : "profit_distribution", Math.abs(data.lots || 1) * rand2(50, 200));
+            this.emitPoolTx(tx);
+          } else if (type === "CLEAR") {
+            const tx = generator.generateLiveTransaction("clearing", "profit_distribution", (data.volume || 1e5) * rand2(1e-4, 5e-4));
+            this.emitPoolTx(tx);
+          }
+        } catch {
+        }
+      }
+      scheduleCycle() {
+        if (!this.running) return;
+        const interval = rand2(8e3, 14e3);
+        this.cycleTimer = setTimeout(() => {
+          if (this.running) {
+            this.runTradeCycle();
+            this.scheduleCycle();
+          }
+        }, interval);
+      }
+      simulatePrice(pairId) {
+        const state = this.pairStates.get(pairId);
+        if (!state) return 0;
+        const volatility = state.pair.id.includes("JPYC") ? 8e-4 : 4e-4;
+        const drift = rand2(-volatility, volatility);
+        const newPrice = state.currentPrice * (1 + drift);
+        const halfSpread = (state.pair.spreadPips + rand2(-0.3, 0.3)) * state.pair.pipSize / 2;
+        state.currentPrice = newPrice;
+        state.bidPrice = newPrice - halfSpread;
+        state.askPrice = newPrice + halfSpread;
+        state.lastSpread = halfSpread * 2 / state.pair.pipSize;
+        return newPrice;
+      }
+      runTradeCycle() {
+        const pairState = pick2(Array.from(this.pairStates.values()));
+        const pair = pairState.pair;
+        const entries = [];
+        let delay = 0;
+        const price = this.simulatePrice(pair.id);
+        const side = Math.random() > 0.5 ? "BUY" : "SELL";
+        const lots = parseFloat(rand2(0.1, 2.5).toFixed(2));
+        const notional = lots * 1e5;
+        const rfqId = tradeId();
+        entries.push({
+          entry: {
+            type: "RFQ",
+            message: `RFQ ${rfqId} | ${pair.symbol} ${side} ${lots.toFixed(2)} lots ($${(notional / 1e3).toFixed(0)}K) | Mid: ${formatRate(price, pair)}`,
+            data: { rfqId, pair: pair.id, side, lots, price },
+            importance: "medium",
+            pairId: pair.id
+          },
+          delay
+        });
+        delay += rand2(400, 800);
+        const quoteSpread = rand2(0.5, 2) * pair.pipSize;
+        const quotePrice = side === "BUY" ? price + quoteSpread : price - quoteSpread;
+        const quotePips = Math.abs(quotePrice - price) / pair.pipSize;
+        entries.push({
+          entry: {
+            type: "QUOTE",
+            message: `QUOTE ${rfqId} | ${pair.symbol} @ ${formatRate(quotePrice, pair)} | Spread: ${quotePips.toFixed(1)} pips | Valid: 3s`,
+            data: { rfqId, quotePrice, spread: quotePips },
+            importance: "medium",
+            pairId: pair.id
+          },
+          delay
+        });
+        delay += rand2(500, 1e3);
+        const matched = Math.random() < 0.85;
+        if (matched) {
+          const matchPrice = quotePrice * (1 + rand2(-5e-5, 5e-5));
+          entries.push({
+            entry: {
+              type: "MATCH",
+              message: `MATCH ${rfqId} | ${pair.symbol} ${side} @ ${formatRate(matchPrice, pair)} | ${lots.toFixed(2)} lots | Counterparty: LP-${randInt2(1, 8)}`,
+              data: { rfqId, matchPrice, counterparty: `LP-${randInt2(1, 8)}` },
+              importance: "high",
+              pairId: pair.id
+            },
+            delay
+          });
+          delay += rand2(1e3, 2500);
+          const settlePrice = matchPrice * (1 + rand2(-2e-5, 2e-5));
+          const pips = (settlePrice - price) / pair.pipSize * (side === "BUY" ? 1 : -1);
+          const pnl = pips * pair.pipSize * lots * 1e5;
+          entries.push({
+            entry: {
+              type: "SETTLE",
+              message: `SETTLE ${rfqId} | PvP confirmed | ${pair.symbol} @ ${formatRate(settlePrice, pair)} | P&L: ${pips >= 0 ? "+" : ""}${pips.toFixed(1)} pips ($${pnl >= 0 ? "+" : ""}${pnl.toFixed(2)})`,
+              data: { rfqId, settlePrice, pips, pnl, pvp: true },
+              importance: "high",
+              pairId: pair.id
+            },
+            delay
+          });
+          delay += rand2(300, 600);
+          entries.push({
+            entry: {
+              type: "PVP",
+              message: `PvP ${rfqId} | Atomic settlement confirmed on-chain | USDC transferred: $${notional.toLocaleString()} | Gas: ~$0.${randInt2(10, 50)}`,
+              data: { rfqId, settled: true, gasWei: randInt2(10, 50) },
+              importance: "medium",
+              pairId: pair.id
+            },
+            delay
+          });
+          this.generatePoolTxFromEvent("SETTLE", { pnl });
+          this.totalTrades++;
+          this.totalPnl += pnl;
+          this.totalPips += pips;
+          this.totalLots += lots;
+          if (Math.random() < 0.4) {
+            this.openPositions.push({
+              id: rfqId,
+              pairId: pair.id,
+              side,
+              lots,
+              pips,
+              entryPrice: matchPrice,
+              currentPrice: settlePrice,
+              pnl,
+              openTime: Date.now()
+            });
+            if (this.openPositions.length > 5) {
+              this.openPositions.shift();
+            }
+          }
+        } else {
+          entries.push({
+            entry: {
+              type: "MATCH",
+              message: `MATCH FAILED ${rfqId} | ${pair.symbol} | No counterparty at requested price | Requoting...`,
+              data: { rfqId, matched: false },
+              importance: "low",
+              pairId: pair.id
+            },
+            delay
+          });
+        }
+        if (Math.random() < 0.2) {
+          delay += rand2(400, 800);
+          const hedgePair = pick2(FOREX_CURRENCY_PAIRS);
+          const hedgeLots = parseFloat(rand2(0.5, 5).toFixed(2));
+          const hedgeDirection = Math.random() > 0.5 ? "LONG" : "SHORT";
+          entries.push({
+            entry: {
+              type: "HEDGE",
+              message: `HEDGE | ${hedgePair.symbol} ${hedgeDirection} ${hedgeLots.toFixed(2)} lots | Pool delta neutralization | Exposure: ${rand2(5, 20).toFixed(1)}%`,
+              data: { pair: hedgePair.id, direction: hedgeDirection, lots: hedgeLots },
+              importance: "medium"
+            },
+            delay
+          });
+          this.generatePoolTxFromEvent("HEDGE", { lots: hedgeLots });
+        }
+        if (Math.random() < 0.15) {
+          delay += rand2(300, 600);
+          const clearAmount = randInt2(5e4, 5e5);
+          entries.push({
+            entry: {
+              type: "CLEAR",
+              message: `CLEAR | Netting cycle complete | Volume: $${(clearAmount / 1e3).toFixed(0)}K | Pairs settled: ${randInt2(2, 6)} | Pool util: ${rand2(60, 85).toFixed(1)}%`,
+              data: { volume: clearAmount, pairsSettled: randInt2(2, 6) },
+              importance: "low"
+            },
+            delay
+          });
+          this.generatePoolTxFromEvent("CLEAR", { volume: clearAmount });
+        }
+        if (this.openPositions.length > 0 && Math.random() < 0.25) {
+          delay += rand2(300, 600);
+          const posUpdates = this.openPositions.slice(0, 3).map((pos) => {
+            const pState = this.pairStates.get(pos.pairId);
+            if (pState) {
+              pos.currentPrice = pState.currentPrice;
+              pos.pips = (pos.currentPrice - pos.entryPrice) / pState.pair.pipSize * (pos.side === "BUY" ? 1 : -1);
+              pos.pnl = pos.pips * pState.pair.pipSize * pos.lots * 1e5;
+            }
+            return `${pState?.pair.symbol || pos.pairId} ${pos.side}: ${pos.pips >= 0 ? "+" : ""}${pos.pips.toFixed(1)} pips`;
+          });
+          entries.push({
+            entry: {
+              type: "POSITION",
+              message: `POSITION | ${posUpdates.join(" | ")} | Open: ${this.openPositions.length}`,
+              data: { positions: this.openPositions.length },
+              importance: "low"
+            },
+            delay
+          });
+          if (this.openPositions.length > 2 && Math.random() < 0.3) {
+            const closed = this.openPositions.shift();
+            this.totalPnl += closed.pnl * rand2(0.01, 0.03);
+          }
+        }
+        if (Math.random() < 0.3) {
+          delay += rand2(300, 600);
+          entries.push({
+            entry: {
+              type: "PNL",
+              message: `PNL | Session: $${this.totalPnl >= 0 ? "+" : ""}${this.totalPnl.toFixed(2)} | Trades: ${this.totalTrades} | Pips: ${this.totalPips >= 0 ? "+" : ""}${this.totalPips.toFixed(1)} | Lots: ${this.totalLots.toFixed(2)}`,
+              data: { totalPnl: this.totalPnl, totalTrades: this.totalTrades, totalPips: this.totalPips },
+              importance: "medium"
+            },
+            delay
+          });
+        }
+        if (Math.random() < 0.1) {
+          delay += rand2(300, 600);
+          entries.push({
+            entry: {
+              type: "SYSTEM",
+              message: `[Market] ${pick2(FX_NEWS)}`,
+              importance: "medium"
+            },
+            delay
+          });
+        }
+        for (const { entry, delay: d } of entries) {
+          setTimeout(() => {
+            if (this.running) {
+              this.emit({
+                ...entry,
+                id: genId2(),
+                timestamp: Date.now()
+              });
+            }
+          }, d);
+        }
+      }
+    };
+    forexSimulationEngine = new ForexSimulationEngine();
+  }
+});
+
+// src/services/forex/BotSimulationEngine.ts
+var BotSimulationEngine_exports = {};
+__export(BotSimulationEngine_exports, {
+  STRATEGY_PERSONALITIES: () => STRATEGY_PERSONALITIES,
+  botSimulationEngine: () => botSimulationEngine
+});
+function genId3() {
+  return `log_${Date.now()}_${++idCounter2}`;
+}
+function rand3(min, max) {
+  return min + Math.random() * (max - min);
+}
+function randInt3(min, max) {
+  return Math.floor(rand3(min, max + 1));
+}
+function pick3(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function clamp(val, min, max) {
+  return Math.max(min, Math.min(max, val));
+}
+function formatPrice(price) {
+  if (price >= 1e3) return price.toFixed(2);
+  if (price >= 1) return price.toFixed(3);
+  return price.toFixed(5);
+}
+var STRATEGY_PERSONALITIES, PAIR_PRICES, CHAIN_INFO, NEWS_HEADLINES, idCounter2, BotSimulationEngine, botSimulationEngine;
+var init_BotSimulationEngine = __esm({
+  "src/services/forex/BotSimulationEngine.ts"() {
+    STRATEGY_PERSONALITIES = [
+      {
+        id: "balanced-01",
+        name: "Balanced Alpha",
+        shortName: "BAL",
+        color: "#3B82F6",
+        scanIntervalMin: 25e3,
+        // Slower: 25-40s between cycles
+        scanIntervalMax: 4e4,
+        tradeFrequency: 0.4,
+        positionSizeMin: 15,
+        positionSizeMax: 35,
+        leverageMin: 3,
+        leverageMax: 10,
+        primaryIndicators: ["RSI", "MACD"],
+        riskTolerance: "medium",
+        preferredPairs: ["BTC/USDT", "ETH/USDT", "SOL/USDT"],
+        rsiBias: 50
+      },
+      {
+        id: "conservative-01",
+        name: "Conservative Shield",
+        shortName: "CON",
+        color: "#10B981",
+        scanIntervalMin: 35e3,
+        // Slower: 35-55s between cycles
+        scanIntervalMax: 55e3,
+        tradeFrequency: 0.25,
+        positionSizeMin: 10,
+        positionSizeMax: 20,
+        leverageMin: 2,
+        leverageMax: 5,
+        primaryIndicators: ["Bollinger", "Volume"],
+        riskTolerance: "low",
+        preferredPairs: ["BTC/USDT", "ETH/USDT"],
+        rsiBias: 45
+      },
+      {
+        id: "aggressive-01",
+        name: "Aggressive Momentum",
+        shortName: "AGG",
+        color: "#EF4444",
+        scanIntervalMin: 18e3,
+        // Slower: 18-30s between cycles
+        scanIntervalMax: 3e4,
+        tradeFrequency: 0.5,
+        positionSizeMin: 25,
+        positionSizeMax: 50,
+        leverageMin: 5,
+        leverageMax: 20,
+        primaryIndicators: ["RSI", "MACD", "EMA", "Volume"],
+        riskTolerance: "high",
+        preferredPairs: ["BTC/USDT", "ETH/USDT", "SOL/USDT", "DOGE/USDT", "AVAX/USDT"],
+        rsiBias: 55
+      }
+    ];
+    PAIR_PRICES = {
+      "BTC/USDT": 67500,
+      "ETH/USDT": 3450,
+      "BNB/USDT": 605,
+      "SOL/USDT": 178,
+      "XRP/USDT": 0.62,
+      "DOGE/USDT": 0.165,
+      "ADA/USDT": 0.45,
+      "AVAX/USDT": 38.5,
+      "ARB/USDT": 1.18,
+      "MATIC/USDT": 0.72,
+      "LINK/USDT": 14.5,
+      "UNI/USDT": 7.8,
+      "AAVE/USDT": 92,
+      "OP/USDT": 2.45,
+      "APT/USDT": 8.9,
+      "INJ/USDT": 24.5,
+      "TIA/USDT": 11.2,
+      "SUI/USDT": 1.65,
+      "DOT/USDT": 7.2,
+      "ATOM/USDT": 9.8,
+      "FIL/USDT": 5.6,
+      "LTC/USDT": 72,
+      "NEAR/USDT": 5.1,
+      "FTM/USDT": 0.42
+    };
+    CHAIN_INFO = {
+      ethereum: { name: "Ethereum", shortName: "ETH", icon: "\u039E" },
+      arbitrum: { name: "Arbitrum", shortName: "ARB", icon: "\u25C6" },
+      bsc: { name: "BSC", shortName: "BSC", icon: "\u25C6" },
+      base: { name: "Base", shortName: "BASE", icon: "\u25CF" },
+      polygon: { name: "Polygon", shortName: "POLY", icon: "\u2B21" },
+      optimism: { name: "Optimism", shortName: "OP", icon: "\u25C9" },
+      avalanche: { name: "Avalanche", shortName: "AVAX", icon: "\u25B2" },
+      linea: { name: "Linea", shortName: "LINEA", icon: "\u2550" },
+      zksync: { name: "zkSync", shortName: "ZK", icon: "\u2B22" },
+      scroll: { name: "Scroll", shortName: "SCRL", icon: "\u25CE" }
+    };
+    NEWS_HEADLINES = [
+      "Fed signals potential rate pause, crypto markets react positively",
+      "Major institutional investor increases BTC allocation by 15%",
+      "On-chain data shows whale accumulation pattern forming",
+      "DeFi TVL reaches new monthly high across major protocols",
+      "Exchange outflows surge as holders move to cold storage",
+      "Options market signals increased volatility expected this week",
+      "Mining difficulty adjustment approaching, hash rate stable",
+      "Regulatory clarity in EU boosts market sentiment",
+      "Stablecoin supply expanding, potential bullish indicator",
+      "Social sentiment score shifts to extreme greed zone",
+      "Cross-chain bridge volume hits record daily high",
+      "Layer 2 adoption metrics show 40% MoM growth"
+    ];
+    idCounter2 = 0;
+    BotSimulationEngine = class {
+      constructor() {
+        this.listeners = [];
+        this.botTimers = /* @__PURE__ */ new Map();
+        this.botStates = /* @__PURE__ */ new Map();
+        this.priceState = /* @__PURE__ */ new Map();
+        this.indicatorState = /* @__PURE__ */ new Map();
+        this.running = false;
+        this.userPairs = [];
+        this.userChains = [];
+        for (const [pair, base] of Object.entries(PAIR_PRICES)) {
+          this.priceState.set(pair, base * (1 + rand3(-0.02, 0.02)));
+        }
+      }
+      // ── Public API ─────────────────────────────────────────────────────────────
+      getStrategies() {
+        return STRATEGY_PERSONALITIES;
+      }
+      start(strategyIds, userPairs, userChains) {
+        this.running = true;
+        this.userPairs = (userPairs || []).map((p) => p.includes("/") ? p : `${p}/USDT`).filter((p) => p in PAIR_PRICES);
+        this.userChains = (userChains || []).filter((c) => c in CHAIN_INFO);
+        const strategies = strategyIds ? STRATEGY_PERSONALITIES.filter((s) => strategyIds.includes(s.id)) : STRATEGY_PERSONALITIES;
+        for (const strategy of strategies) {
+          this.initBotState(strategy);
+          this.scheduleCycle(strategy);
+        }
+      }
+      stop(strategyIds) {
+        const ids = strategyIds || Array.from(this.botTimers.keys());
+        for (const id of ids) {
+          const timer = this.botTimers.get(id);
+          if (timer) {
+            clearTimeout(timer);
+            this.botTimers.delete(id);
+          }
+        }
+        if (!strategyIds) {
+          this.running = false;
+        }
+      }
+      onLog(callback) {
+        this.listeners.push(callback);
+        return () => {
+          this.listeners = this.listeners.filter((l) => l !== callback);
+        };
+      }
+      getBotState(strategyId) {
+        return this.botStates.get(strategyId);
+      }
+      getAllBotStates() {
+        return this.botStates;
+      }
+      isRunning() {
+        return this.running;
+      }
+      emitBootSequence() {
+        const bootMessages = [
+          { msg: "Initializing ONE Trading Engine v3.2.1...", delay: 0 },
+          { msg: "Loading market data feeds...", delay: 500 },
+          { msg: "Connecting to exchange WebSocket streams...", delay: 1200 },
+          { msg: "Calibrating indicator engines (RSI, MACD, EMA, Bollinger)...", delay: 2e3 },
+          { msg: "Loading strategy personalities: balanced-01, conservative-01, aggressive-01", delay: 2800 },
+          { msg: "Risk management module initialized (max drawdown: 15%)", delay: 3600 },
+          { msg: "Portfolio allocation engine ready", delay: 4200 },
+          { msg: "=== All systems online. Starting trading cycles ===", delay: 5e3 }
+        ];
+        for (const { msg, delay } of bootMessages) {
+          setTimeout(() => {
+            this.emit({
+              id: genId3(),
+              timestamp: Date.now(),
+              strategyId: "system",
+              strategyName: "SYSTEM",
+              type: "SYSTEM",
+              message: msg,
+              importance: "medium"
+            });
+          }, delay);
+        }
+      }
+      destroy() {
+        this.stop();
+        this.listeners = [];
+        this.botStates.clear();
+        this.priceState.clear();
+        this.indicatorState.clear();
+        this.userPairs = [];
+        this.userChains = [];
+      }
+      // ── Private Methods ────────────────────────────────────────────────────────
+      emit(entry) {
+        for (const listener of this.listeners) {
+          listener(entry);
+        }
+      }
+      getActivePairs(strategy) {
+        return this.userPairs.length > 0 ? this.userPairs : strategy.preferredPairs;
+      }
+      getActiveChain() {
+        const chains = this.userChains.length > 0 ? this.userChains : ["ethereum", "arbitrum", "bsc"];
+        return pick3(chains);
+      }
+      getChainLabel(chainId) {
+        const info = CHAIN_INFO[chainId];
+        return info ? info.shortName : chainId;
+      }
+      initBotState(strategy) {
+        const activePairs = this.getActivePairs(strategy);
+        const pair = pick3(activePairs);
+        const price = this.priceState.get(pair) || PAIR_PRICES[pair] || 5e4;
+        const indicators = this.generateIndicators(strategy, price);
+        this.indicatorState.set(strategy.id, indicators);
+        this.botStates.set(strategy.id, {
+          strategyId: strategy.id,
+          strategyName: strategy.name,
+          isRunning: true,
+          currentPair: pair,
+          currentPrice: price,
+          indicators,
+          openPositions: [],
+          totalPnl: rand3(-50, 200),
+          totalTrades: randInt3(5, 25),
+          winRate: rand3(0.48, 0.68),
+          lastSignal: "HOLD",
+          lastSignalConfidence: 0
+        });
+      }
+      scheduleCycle(strategy) {
+        if (!this.running) return;
+        const interval = rand3(strategy.scanIntervalMin, strategy.scanIntervalMax);
+        const timer = setTimeout(() => {
+          if (this.running) {
+            this.runBotCycle(strategy);
+            this.scheduleCycle(strategy);
+          }
+        }, interval);
+        this.botTimers.set(strategy.id, timer);
+      }
+      async runBotCycle(strategy) {
+        const state = this.botStates.get(strategy.id);
+        if (!state) return;
+        const activePairs = this.getActivePairs(strategy);
+        const pair = pick3(activePairs);
+        const price = this.simulatePrice(pair);
+        const indicators = this.generateIndicators(strategy, price);
+        this.indicatorState.set(strategy.id, indicators);
+        state.currentPair = pair;
+        state.currentPrice = price;
+        state.indicators = indicators;
+        const entries = [];
+        let delay = 0;
+        const chain = this.getActiveChain();
+        const chainLabel = this.getChainLabel(chain);
+        entries.push({
+          entry: {
+            strategyId: strategy.id,
+            strategyName: strategy.shortName,
+            type: "SCAN",
+            message: `Scanning ${pair} on ${chainLabel} | Price: $${formatPrice(price)}`,
+            data: { pair, chain, chainLabel },
+            importance: "low"
+          },
+          delay
+        });
+        delay += rand3(800, 1500);
+        const thinkingMessages = this.generateThinkingProcess(strategy, pair, price);
+        for (const thinking of thinkingMessages) {
+          entries.push({
+            entry: {
+              strategyId: strategy.id,
+              strategyName: strategy.shortName,
+              type: "THINKING",
+              message: thinking,
+              importance: "low"
+            },
+            delay
+          });
+          delay += rand3(600, 1200);
+        }
+        const indicatorParts = [];
+        if (strategy.primaryIndicators.includes("RSI") || strategy.primaryIndicators.includes("MACD")) {
+          indicatorParts.push(`RSI: ${indicators.rsi.toFixed(1)}`);
+        }
+        if (strategy.primaryIndicators.includes("MACD") || strategy.primaryIndicators.includes("RSI")) {
+          indicatorParts.push(`MACD: ${indicators.macd.histogram > 0 ? "+" : ""}${indicators.macd.histogram.toFixed(3)}`);
+        }
+        if (strategy.primaryIndicators.includes("EMA")) {
+          indicatorParts.push(`EMA: ${indicators.ema.short.toFixed(1)}/${indicators.ema.long.toFixed(1)}`);
+          if (indicators.ema.crossover !== "none") {
+            indicatorParts.push(`[${indicators.ema.crossover.toUpperCase()} CROSS]`);
+          }
+        }
+        if (strategy.primaryIndicators.includes("Bollinger")) {
+          indicatorParts.push(`BB: ${indicators.bollinger.position.toFixed(1)}% width=${indicators.bollinger.width.toFixed(2)}`);
+        }
+        if (strategy.primaryIndicators.includes("Volume")) {
+          indicatorParts.push(`Vol: ${indicators.volume.ratio.toFixed(2)}x avg`);
+        }
+        entries.push({
+          entry: {
+            strategyId: strategy.id,
+            strategyName: strategy.shortName,
+            type: "INDICATOR",
+            message: indicatorParts.join(" | "),
+            data: { indicators },
+            importance: "low"
+          },
+          delay
+        });
+        delay += rand3(800, 1500);
+        if (Math.random() < 0.12) {
+          const sentiment = Math.random() > 0.4 ? "Bullish" : "Bearish";
+          entries.push({
+            entry: {
+              strategyId: strategy.id,
+              strategyName: strategy.shortName,
+              type: "NEWS",
+              message: `[${sentiment}] ${pick3(NEWS_HEADLINES)}`,
+              importance: "medium"
+            },
+            delay
+          });
+          delay += rand3(1e3, 1800);
+        }
+        if (Math.random() < 0.4) {
+          const analysis = this.generateAnalysis(strategy, indicators, pair);
+          entries.push({
+            entry: {
+              strategyId: strategy.id,
+              strategyName: strategy.shortName,
+              type: "ANALYSIS",
+              message: analysis,
+              importance: "medium"
+            },
+            delay
+          });
+          delay += rand3(1e3, 2e3);
+        }
+        const signal = this.evaluateSignal(strategy, indicators);
+        state.lastSignal = signal.direction;
+        state.lastSignalConfidence = signal.confidence;
+        if (signal.direction !== "HOLD") {
+          const strategyContext = this.generateStrategyContext(strategy, signal, indicators, pair);
+          entries.push({
+            entry: {
+              strategyId: strategy.id,
+              strategyName: strategy.shortName,
+              type: "STRATEGY",
+              message: strategyContext,
+              data: {
+                strategy: strategy.name,
+                riskTolerance: strategy.riskTolerance,
+                primaryIndicators: strategy.primaryIndicators,
+                signal: signal.direction,
+                confidence: signal.confidence
+              },
+              importance: "high"
+            },
+            delay
+          });
+          delay += rand3(1500, 2500);
+          entries.push({
+            entry: {
+              strategyId: strategy.id,
+              strategyName: strategy.shortName,
+              type: "SIGNAL",
+              message: `${signal.direction} signal detected | Confidence: ${(signal.confidence * 100).toFixed(1)}% | ${signal.reason}`,
+              data: { signal },
+              importance: "high"
+            },
+            delay
+          });
+          delay += rand3(1200, 2e3);
+          const decision = this.makeTradeDecision(strategy, signal, state);
+          if (decision.execute) {
+            entries.push({
+              entry: {
+                strategyId: strategy.id,
+                strategyName: strategy.shortName,
+                type: "DECISION",
+                message: `Execute ${signal.direction} | Size: ${decision.positionSize.toFixed(1)}% | Leverage: ${decision.leverage}x | Risk/Reward: 1:${decision.riskReward.toFixed(1)}`,
+                data: {
+                  strategyName: strategy.name,
+                  strategyId: strategy.id,
+                  riskTolerance: strategy.riskTolerance,
+                  signalReason: signal.reason,
+                  confidence: signal.confidence
+                },
+                importance: "high"
+              },
+              delay
+            });
+            delay += rand3(1e3, 1800);
+            const orderId = `ORD_${Date.now().toString(36).toUpperCase()}`;
+            const orderPrice = signal.direction === "LONG" ? price * (1 - rand3(1e-4, 5e-4)) : price * (1 + rand3(1e-4, 5e-4));
+            entries.push({
+              entry: {
+                strategyId: strategy.id,
+                strategyName: strategy.shortName,
+                type: "ORDER",
+                message: `Submitting ${signal.direction} order | ${pair} @ $${formatPrice(orderPrice)} on ${chainLabel} | ID: ${orderId}`,
+                data: {
+                  orderId,
+                  pair,
+                  side: signal.direction,
+                  price: orderPrice,
+                  leverage: decision.leverage,
+                  chain,
+                  chainLabel,
+                  strategyName: strategy.name,
+                  strategyContext,
+                  signalReason: signal.reason
+                },
+                importance: "high"
+              },
+              delay
+            });
+            delay += rand3(2e3, 4e3);
+            const fillPrice = orderPrice * (1 + rand3(-3e-4, 3e-4));
+            const slippage = Math.abs(fillPrice - orderPrice) / orderPrice * 100;
+            entries.push({
+              entry: {
+                strategyId: strategy.id,
+                strategyName: strategy.shortName,
+                type: "FILLED",
+                message: `Order FILLED | ${pair} ${signal.direction} @ $${formatPrice(fillPrice)} on ${chainLabel} | Slippage: ${slippage.toFixed(4)}% | ID: ${orderId}`,
+                data: {
+                  orderId,
+                  fillPrice,
+                  slippage,
+                  chain,
+                  chainLabel,
+                  strategyName: strategy.name,
+                  executedBy: strategy.id
+                },
+                importance: "high"
+              },
+              delay
+            });
+            const position = {
+              id: orderId,
+              pair,
+              side: signal.direction,
+              entryPrice: fillPrice,
+              currentPrice: price,
+              size: decision.positionSize,
+              leverage: decision.leverage,
+              pnl: 0,
+              pnlPercent: 0
+            };
+            state.openPositions = [...state.openPositions.slice(-2), position];
+            state.totalTrades++;
+          } else {
+            entries.push({
+              entry: {
+                strategyId: strategy.id,
+                strategyName: strategy.shortName,
+                type: "DECISION",
+                message: `SKIP - ${decision.reason}`,
+                importance: "medium"
+              },
+              delay
+            });
+          }
+        }
+        if (state.openPositions.length > 0 && Math.random() < 0.5) {
+          delay += rand3(1500, 2500);
+          let totalPositionPnl = 0;
+          const pnlParts = [];
+          for (const pos of state.openPositions) {
+            pos.currentPrice = this.simulatePrice(pos.pair);
+            const priceDiff = pos.side === "LONG" ? (pos.currentPrice - pos.entryPrice) / pos.entryPrice : (pos.entryPrice - pos.currentPrice) / pos.entryPrice;
+            pos.pnlPercent = priceDiff * pos.leverage * 100;
+            pos.pnl = priceDiff * pos.leverage * pos.size;
+            totalPositionPnl += pos.pnl;
+            pnlParts.push(`${pos.pair} ${pos.side}: ${pos.pnlPercent >= 0 ? "+" : ""}${pos.pnlPercent.toFixed(2)}%`);
+          }
+          state.totalPnl += totalPositionPnl * rand3(0.01, 0.05);
+          if (state.openPositions.length > 1 && Math.random() < 0.3) {
+            const closed = state.openPositions.shift();
+            const finalPnl = closed.pnlPercent;
+            if (finalPnl > 0) {
+              state.winRate = state.winRate * 0.95 + 0.05;
+            } else {
+              state.winRate = state.winRate * 0.95;
+            }
+            state.winRate = clamp(state.winRate, 0.35, 0.75);
+            pnlParts.push(`CLOSED ${closed.pair}: ${finalPnl >= 0 ? "+" : ""}${finalPnl.toFixed(2)}%`);
+          }
+          entries.push({
+            entry: {
+              strategyId: strategy.id,
+              strategyName: strategy.shortName,
+              type: "PNL",
+              message: pnlParts.join(" | "),
+              data: { totalPnl: state.totalPnl, positions: state.openPositions.length },
+              importance: "medium"
+            },
+            delay
+          });
+        }
+        if (Math.random() < 0.2) {
+          delay += rand3(1e3, 2e3);
+          const exposure = state.openPositions.reduce((sum, p) => sum + p.size * p.leverage, 0);
+          const maxDrawdown = rand3(2, 12);
+          entries.push({
+            entry: {
+              strategyId: strategy.id,
+              strategyName: strategy.shortName,
+              type: "RISK",
+              message: `Portfolio exposure: ${exposure.toFixed(1)}% | Max drawdown: ${maxDrawdown.toFixed(1)}% | Open positions: ${state.openPositions.length} | Win rate: ${(state.winRate * 100).toFixed(1)}%`,
+              importance: exposure > 80 ? "high" : "low"
+            },
+            delay
+          });
+        }
+        for (const { entry, delay: d } of entries) {
+          setTimeout(() => {
+            if (this.running) {
+              this.emit({
+                ...entry,
+                id: genId3(),
+                timestamp: Date.now()
+              });
+            }
+          }, d);
+        }
+      }
+      simulatePrice(pair) {
+        const current = this.priceState.get(pair) || PAIR_PRICES[pair] || 5e4;
+        const volatility = pair.includes("DOGE") ? 5e-3 : pair.includes("BTC") ? 2e-3 : 3e-3;
+        const drift = rand3(-volatility, volatility);
+        const newPrice = current * (1 + drift);
+        this.priceState.set(pair, newPrice);
+        return newPrice;
+      }
+      generateIndicators(strategy, price) {
+        const prev = this.indicatorState.get(strategy.id);
+        const prevRsi = prev?.rsi ?? strategy.rsiBias;
+        const rsiMean = strategy.rsiBias;
+        const rsiDrift = rand3(-8, 8);
+        const rsiReversion = (rsiMean - prevRsi) * 0.15;
+        const rsi = clamp(prevRsi + rsiDrift + rsiReversion, 8, 95);
+        const macdBias = rsi > 65 ? 0.3 : rsi < 35 ? -0.3 : 0;
+        const prevHist = prev?.macd.histogram ?? 0;
+        const histogram = clamp(prevHist * 0.7 + rand3(-0.5, 0.5) + macdBias, -2, 2);
+        const macdValue = histogram * rand3(0.8, 1.5);
+        const macdSignal = macdValue - histogram;
+        const prevShort = prev?.ema.short ?? price;
+        const prevLong = prev?.ema.long ?? price;
+        const emaShort = prevShort * 0.9 + price * 0.1;
+        const emaLong = prevLong * 0.95 + price * 0.05;
+        let crossover = "none";
+        if (prevShort <= prevLong && emaShort > emaLong) crossover = "golden";
+        else if (prevShort >= prevLong && emaShort < emaLong) crossover = "death";
+        const bbMiddle = price;
+        const bbWidth = price * rand3(0.01, 0.04);
+        const bbUpper = bbMiddle + bbWidth;
+        const bbLower = bbMiddle - bbWidth;
+        const bbPosition = (price - bbLower) / (bbUpper - bbLower) * 100;
+        const volRatio = rand3(0.3, 2.5);
+        const volCurrent = rand3(1e5, 5e6);
+        return {
+          rsi,
+          macd: { value: macdValue, signal: macdSignal, histogram },
+          ema: { short: emaShort, long: emaLong, crossover },
+          bollinger: { upper: bbUpper, middle: bbMiddle, lower: bbLower, width: bbWidth / price, position: bbPosition },
+          volume: { current: volCurrent, average: volCurrent / volRatio, ratio: volRatio }
+        };
+      }
+      generateThinkingProcess(strategy, pair, price) {
+        const thoughts = [];
+        const pairBase = pair.split("/")[0];
+        const thinkingTemplates = [
+          `Analyzing ${pairBase} market structure...`,
+          `Checking ${strategy.primaryIndicators.join(", ")} confluence...`,
+          `Evaluating risk parameters for ${strategy.riskTolerance} tolerance...`,
+          `Scanning order book depth at $${formatPrice(price)}...`,
+          `Cross-referencing with historical patterns...`,
+          `Calculating optimal entry zone...`,
+          `Assessing market sentiment indicators...`,
+          `Monitoring whale activity on ${pairBase}...`,
+          `Comparing momentum across timeframes...`,
+          `Validating support/resistance levels...`
+        ];
+        const numThoughts = randInt3(1, 3);
+        const shuffled = [...thinkingTemplates].sort(() => Math.random() - 0.5);
+        for (let i = 0; i < numThoughts; i++) {
+          thoughts.push(shuffled[i]);
+        }
+        return thoughts;
+      }
+      generateStrategyContext(strategy, signal, indicators, pair) {
+        const contexts = [];
+        contexts.push(`[${strategy.name}]`);
+        const riskLevel = strategy.riskTolerance === "high" ? "aggressive" : strategy.riskTolerance === "low" ? "conservative" : "balanced";
+        contexts.push(`Risk: ${riskLevel}`);
+        if (indicators.rsi < 35 || indicators.rsi > 65) {
+          contexts.push(`RSI ${indicators.rsi < 35 ? "oversold" : "overbought"} (${indicators.rsi.toFixed(1)})`);
+        }
+        if (indicators.ema.crossover !== "none") {
+          contexts.push(`EMA ${indicators.ema.crossover} cross`);
+        }
+        if (Math.abs(indicators.macd.histogram) > 0.3) {
+          contexts.push(`MACD ${indicators.macd.histogram > 0 ? "bullish" : "bearish"} momentum`);
+        }
+        const confLevel = signal.confidence > 0.7 ? "HIGH" : signal.confidence > 0.5 ? "MEDIUM" : "LOW";
+        contexts.push(`Confidence: ${confLevel}`);
+        return contexts.join(" | ");
+      }
+      generateAnalysis(strategy, indicators, pair) {
+        const analyses = [];
+        if (indicators.rsi > 70) {
+          analyses.push(`RSI at ${indicators.rsi.toFixed(1)} - overbought territory, watching for reversal`);
+        } else if (indicators.rsi < 30) {
+          analyses.push(`RSI at ${indicators.rsi.toFixed(1)} - oversold, potential bounce setup`);
+        } else if (indicators.rsi > 55) {
+          analyses.push(`RSI trending bullish at ${indicators.rsi.toFixed(1)}`);
+        } else {
+          analyses.push(`RSI neutral at ${indicators.rsi.toFixed(1)}, no clear direction`);
+        }
+        if (indicators.macd.histogram > 0.5) {
+          analyses.push("MACD histogram expanding positive - momentum building");
+        } else if (indicators.macd.histogram < -0.5) {
+          analyses.push("MACD histogram expanding negative - bearish pressure");
+        }
+        if (indicators.ema.crossover === "golden") {
+          analyses.push("EMA golden cross detected - strong bullish signal");
+        } else if (indicators.ema.crossover === "death") {
+          analyses.push("EMA death cross detected - bearish warning");
+        }
+        if (indicators.bollinger.position > 90) {
+          analyses.push(`Price near upper Bollinger band (${indicators.bollinger.position.toFixed(0)}%) - potential resistance`);
+        } else if (indicators.bollinger.position < 10) {
+          analyses.push(`Price near lower Bollinger band (${indicators.bollinger.position.toFixed(0)}%) - potential support`);
+        }
+        if (indicators.volume.ratio > 1.8) {
+          analyses.push(`Volume spike ${indicators.volume.ratio.toFixed(1)}x average - high activity`);
+        }
+        return analyses.length > 0 ? analyses.join(" | ") : `${pair} consolidating - waiting for clearer setup`;
+      }
+      evaluateSignal(strategy, indicators) {
+        let bullScore = 0;
+        let bearScore = 0;
+        const reasons = [];
+        if (indicators.rsi < 30) {
+          bullScore += 2;
+          reasons.push("RSI oversold");
+        } else if (indicators.rsi < 40) {
+          bullScore += 1;
+          reasons.push("RSI low");
+        } else if (indicators.rsi > 70) {
+          bearScore += 2;
+          reasons.push("RSI overbought");
+        } else if (indicators.rsi > 60) {
+          bearScore += 1;
+          reasons.push("RSI high");
+        }
+        if (indicators.macd.histogram > 0.3) {
+          bullScore += 1.5;
+          reasons.push("MACD bullish");
+        } else if (indicators.macd.histogram < -0.3) {
+          bearScore += 1.5;
+          reasons.push("MACD bearish");
+        }
+        if (indicators.ema.crossover === "golden") {
+          bullScore += 2.5;
+          reasons.push("Golden cross");
+        } else if (indicators.ema.crossover === "death") {
+          bearScore += 2.5;
+          reasons.push("Death cross");
+        } else if (indicators.ema.short > indicators.ema.long) {
+          bullScore += 0.5;
+        } else {
+          bearScore += 0.5;
+        }
+        if (indicators.bollinger.position < 15) {
+          bullScore += 1;
+          reasons.push("BB support");
+        } else if (indicators.bollinger.position > 85) {
+          bearScore += 1;
+          reasons.push("BB resistance");
+        }
+        if (indicators.volume.ratio > 1.5) {
+          if (bullScore > bearScore) bullScore += 1;
+          else bearScore += 1;
+          reasons.push("Volume confirms");
+        }
+        const netScore = bullScore - bearScore;
+        const confidence = Math.min(Math.abs(netScore) / 6, 0.95);
+        const threshold = strategy.riskTolerance === "high" ? 1.5 : strategy.riskTolerance === "medium" ? 2 : 2.5;
+        if (Math.random() > strategy.tradeFrequency) {
+          return { direction: "HOLD", confidence: 0, reason: "Cycle skip" };
+        }
+        if (netScore > threshold) {
+          return { direction: "LONG", confidence, reason: reasons.slice(0, 3).join(", ") };
+        } else if (netScore < -threshold) {
+          return { direction: "SHORT", confidence, reason: reasons.slice(0, 3).join(", ") };
+        }
+        return { direction: "HOLD", confidence: 0, reason: "No clear signal" };
+      }
+      makeTradeDecision(strategy, signal, state) {
+        if (state.openPositions.length >= 3) {
+          return { execute: false, positionSize: 0, leverage: 0, riskReward: 0, reason: "Max positions reached (3)" };
+        }
+        const minConfidence = strategy.riskTolerance === "high" ? 0.3 : strategy.riskTolerance === "medium" ? 0.45 : 0.6;
+        if (signal.confidence < minConfidence) {
+          return { execute: false, positionSize: 0, leverage: 0, riskReward: 0, reason: `Confidence too low (${(signal.confidence * 100).toFixed(0)}% < ${(minConfidence * 100).toFixed(0)}%)` };
+        }
+        const positionSize = rand3(strategy.positionSizeMin, strategy.positionSizeMax);
+        const leverage = randInt3(strategy.leverageMin, strategy.leverageMax);
+        const riskReward = rand3(1.2, 3.5);
+        return { execute: true, positionSize, leverage, riskReward, reason: "" };
+      }
+    };
+    botSimulationEngine = new BotSimulationEngine();
+  }
+});
 function getConfig() {
   {
     throw new Error("ONE SDK not initialized. Call initOneSDK() first.");
@@ -1695,17 +3376,1559 @@ function useAITrading() {
     error
   };
 }
+function useAIAgents(includeInactive = false) {
+  const [agents, setAgents] = react.useState([]);
+  const [shareRates, setShareRates] = react.useState({});
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const fetchAgents = react.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]);
+  react.useEffect(() => {
+    fetchAgents();
+  }, [fetchAgents]);
+  return { agents, shareRates, isLoading, error, refresh: fetchAgents };
+}
+function useAIAgent(agentId) {
+  const [agent, setAgent] = react.useState(null);
+  const [params, setParams] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const fetchAgent = react.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]);
+  react.useEffect(() => {
+    fetchAgent();
+  }, [fetchAgent]);
+  const calculateParams = react.useCallback(async (amount, cycleDays) => {
+    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 };
+}
+function useAIAgentSubscription() {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const subscribe = react.useCallback(async (agentId, amount, cycleDays, txHash) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      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 };
+}
+
+// src/hooks/useForexTrading.ts
+init_forex();
+var _forexAccessToken = null;
+var _forexEngineUrl = "https://api.one23.io";
+function setForexAccessToken(token) {
+  _forexAccessToken = token;
+}
+function clearForexAccessToken() {
+  _forexAccessToken = null;
+}
+function setForexEngineUrl(url) {
+  _forexEngineUrl = url;
+}
+async function forexApi(path, options) {
+  try {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (_forexAccessToken) {
+      headers["Authorization"] = `Bearer ${_forexAccessToken}`;
+    }
+    const res = await fetch(`${_forexEngineUrl}${path}`, { ...options, headers });
+    if (!res.ok) return null;
+    const json = await res.json();
+    return json?.data ?? json;
+  } catch {
+    return null;
+  }
+}
+function useForexPools(options) {
+  const [pools, setPools] = react.useState(FOREX_POOL_DEFAULTS);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const fetchPools = react.useCallback(async () => {
+    setIsLoading(true);
+    try {
+      const data = await forexApi("/api/forex/pools");
+      if (data?.pools) {
+        setPools(data.pools.map((p) => ({
+          id: p.type ?? p.id,
+          nameKey: `forex.pool_${p.type ?? p.id}`,
+          descriptionKey: `forex.pool_${p.type ?? p.id}_desc`,
+          allocation: p.allocation ?? (p.type === "clearing" ? 0.5 : p.type === "hedging" ? 0.3 : 0.2),
+          totalSize: p.totalSize ?? p.total_size ?? 0,
+          utilization: p.utilization ?? 0,
+          color: p.type === "clearing" ? "#3B82F6" : p.type === "hedging" ? "#F59E0B" : "#10B981",
+          apy7d: p.apy7d ?? 0,
+          apy30d: p.apy30d ?? 0,
+          netFlow24h: p.netFlow24h ?? 0,
+          txCount24h: p.txCount24h ?? 0,
+          txCountTotal: p.txCountTotal ?? 0,
+          totalDeposits: p.totalDeposits ?? 0,
+          totalWithdrawals: p.totalWithdrawals ?? 0,
+          profitDistributed: p.profitDistributed ?? 0,
+          lastUpdated: p.lastUpdated ?? Date.now()
+        })));
+      }
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to fetch pools");
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  react.useEffect(() => {
+    fetchPools();
+    if (options?.refreshInterval) {
+      const timer = setInterval(fetchPools, options.refreshInterval);
+      return () => clearInterval(timer);
+    }
+  }, [fetchPools, options?.refreshInterval]);
+  return { pools, isLoading, error, refresh: fetchPools };
+}
+function useForexInvestments(options) {
+  const [investments, setInvestments] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const fetchInvestments = react.useCallback(async () => {
+    setIsLoading(true);
+    try {
+      const data = await forexApi("/api/forex/investments");
+      if (data?.investments) {
+        setInvestments(data.investments.map(mapInvestment));
+      }
+      setError(null);
+    } catch {
+      setError("Failed to fetch investments");
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const createInvestment = react.useCallback(async (params) => {
+    setIsLoading(true);
+    try {
+      const data = await forexApi("/api/forex/investments", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+      if (data?.investment) {
+        const inv2 = mapInvestment(data.investment);
+        setInvestments((prev) => [inv2, ...prev]);
+        return inv2;
+      }
+      const inv = createLocalInvestment(params);
+      setInvestments((prev) => [inv, ...prev]);
+      return inv;
+    } catch {
+      const inv = createLocalInvestment(params);
+      setInvestments((prev) => [inv, ...prev]);
+      return inv;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const redeemInvestment = react.useCallback(async (investmentId) => {
+    try {
+      await forexApi(`/api/forex/investments/${investmentId}/redeem`, { method: "POST" });
+      setInvestments((prev) => prev.map(
+        (inv) => inv.id === investmentId ? { ...inv, status: "redeemed" } : inv
+      ));
+      return true;
+    } catch {
+      return false;
+    }
+  }, []);
+  react.useEffect(() => {
+    fetchInvestments();
+    if (options?.refreshInterval) {
+      const timer = setInterval(fetchInvestments, options.refreshInterval);
+      return () => clearInterval(timer);
+    }
+  }, [fetchInvestments, options?.refreshInterval]);
+  const portfolioSummary = react.useMemo(() => {
+    const active = investments.filter((i) => i.status === "active");
+    return {
+      totalInvested: active.reduce((s, i) => s + i.amount, 0),
+      totalValue: active.reduce((s, i) => s + i.currentValue, 0),
+      totalProfit: active.reduce((s, i) => s + i.profit, 0),
+      activeCount: active.length
+    };
+  }, [investments]);
+  return { investments, isLoading, error, createInvestment, redeemInvestment, refresh: fetchInvestments, portfolioSummary };
+}
+function useForexSimulation(options) {
+  const maxLogs = options?.maxLogs ?? 500;
+  const [logs, setLogs] = react.useState([]);
+  const [poolTxs, setPoolTxs] = react.useState([]);
+  const [isRunning, setIsRunning] = react.useState(false);
+  const [stats, setStats] = react.useState({ totalPnl: 0, totalTrades: 0, totalPips: 0, totalLots: 0 });
+  const engineRef = react.useRef(null);
+  const getEngine = react.useCallback(() => {
+    if (!engineRef.current) {
+      try {
+        const { forexSimulationEngine: forexSimulationEngine2 } = (init_ForexSimulationEngine(), __toCommonJS(ForexSimulationEngine_exports));
+        engineRef.current = forexSimulationEngine2;
+      } catch {
+      }
+    }
+    return engineRef.current;
+  }, []);
+  const start = react.useCallback(() => {
+    const engine = getEngine();
+    if (!engine) return;
+    if (!engine.isRunning()) engine.start();
+    setIsRunning(true);
+  }, [getEngine]);
+  const stop = react.useCallback(() => {
+    const engine = getEngine();
+    if (engine) engine.stop();
+    setIsRunning(false);
+  }, [getEngine]);
+  const clearLogs = react.useCallback(() => {
+    setLogs([]);
+    setPoolTxs([]);
+  }, []);
+  react.useEffect(() => {
+    const engine = getEngine();
+    if (!engine) return;
+    const unsubLog = engine.onLog((entry) => {
+      setLogs((prev) => {
+        const next = [...prev, entry];
+        return next.length > maxLogs ? next.slice(-maxLogs) : next;
+      });
+      const s = engine.getStats();
+      setStats({ totalPnl: s.totalPnl, totalTrades: s.totalTrades, totalPips: s.totalPips, totalLots: s.totalLots });
+    });
+    const unsubTx = engine.onPoolTransaction((tx) => {
+      setPoolTxs((prev) => [...prev.slice(-999), tx]);
+    });
+    return () => {
+      unsubLog();
+      unsubTx();
+    };
+  }, [getEngine, maxLogs]);
+  return { logs, poolTransactions: poolTxs, isRunning, stats, start, stop, clearLogs };
+}
+function useForexPoolData() {
+  const [snapshots, setSnapshots] = react.useState({ clearing: [], hedging: [], insurance: [] });
+  const [transactions, setTransactions] = react.useState([]);
+  const [isInitialized, setIsInitialized] = react.useState(false);
+  const initialize = react.useCallback(() => {
+    if (isInitialized) return;
+    try {
+      const { ForexPoolDataGenerator: ForexPoolDataGenerator2 } = (init_ForexPoolDataGenerator(), __toCommonJS(ForexPoolDataGenerator_exports));
+      const gen = ForexPoolDataGenerator2.getInstance();
+      setSnapshots(gen.generateAllSnapshots());
+      setTransactions(gen.generateAllTransactions());
+      setIsInitialized(true);
+    } catch {
+    }
+  }, [isInitialized]);
+  return { snapshots, transactions, isInitialized, initialize };
+}
+function useForexTrading(options) {
+  const pools = useForexPools({ refreshInterval: options?.poolRefreshInterval });
+  const investments = useForexInvestments({ refreshInterval: options?.investmentRefreshInterval });
+  const simulation = useForexSimulation();
+  const poolData = useForexPoolData();
+  return {
+    pools,
+    investments,
+    simulation,
+    poolData,
+    capitalSplit: FOREX_CAPITAL_SPLIT,
+    agent: FOREX_AGENT,
+    currencyPairs: (init_forex(), __toCommonJS(forex_exports)).FOREX_CURRENCY_PAIRS,
+    cycleOptions: (init_forex(), __toCommonJS(forex_exports)).FOREX_CYCLE_OPTIONS,
+    computePoolAllocations,
+    estimateProfit: estimateForexProfit
+  };
+}
+function mapInvestment(raw) {
+  const cycleDays = raw.cycleDays ?? raw.cycle_days ?? 90;
+  const cycleOption = FOREX_CYCLE_OPTIONS.find((c) => c.days === cycleDays) || FOREX_CYCLE_OPTIONS[2];
+  const amount = typeof raw.amount === "string" ? parseFloat(raw.amount) : raw.amount ?? 0;
+  const allocs = computePoolAllocations(amount);
+  return {
+    id: raw.id,
+    userId: raw.userId ?? raw.user_id,
+    amount,
+    currentValue: raw.currentValue ?? raw.current_value ?? amount,
+    profit: raw.profit ?? 0,
+    status: raw.status ?? "active",
+    selectedPairs: raw.selectedPairs ?? raw.selected_pairs ?? [],
+    cycleDays,
+    cycleOption,
+    feeRate: raw.feeRate ?? cycleOption.feeRate,
+    commissionRate: raw.commissionRate ?? cycleOption.commissionRate,
+    startDate: raw.startDate ?? raw.start_date ?? (/* @__PURE__ */ new Date()).toISOString(),
+    endDate: raw.endDate ?? raw.end_date ?? "",
+    tradingCapital: raw.tradingCapital ?? allocs.tradingCapital,
+    totalPoolReserves: raw.totalPoolReserves ?? allocs.totalPoolReserves,
+    poolAllocations: raw.poolAllocations ?? {
+      clearing: allocs.clearing,
+      hedging: allocs.hedging,
+      insurance: allocs.insurance
+    },
+    tradeWeight: raw.tradeWeight ?? 0,
+    totalLots: raw.totalLots ?? 0,
+    totalPips: raw.totalPips ?? 0,
+    totalTrades: raw.totalTrades ?? 0,
+    positions: raw.positions ?? [],
+    tradeHistory: raw.tradeHistory ?? [],
+    redeemedAt: raw.redeemedAt,
+    createdAt: raw.createdAt,
+    updatedAt: raw.updatedAt
+  };
+}
+function createLocalInvestment(params) {
+  const { amount, selectedPairs, cycleDays } = params;
+  const cycleOption = FOREX_CYCLE_OPTIONS.find((c) => c.days === cycleDays) || FOREX_CYCLE_OPTIONS[2];
+  const allocs = computePoolAllocations(amount);
+  const now = /* @__PURE__ */ new Date();
+  const endDate = new Date(now);
+  endDate.setDate(endDate.getDate() + cycleDays);
+  return {
+    id: `fx_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    amount,
+    currentValue: amount,
+    profit: 0,
+    status: "active",
+    selectedPairs,
+    cycleDays,
+    cycleOption,
+    startDate: now.toISOString(),
+    endDate: endDate.toISOString(),
+    tradingCapital: allocs.tradingCapital,
+    totalPoolReserves: allocs.totalPoolReserves,
+    poolAllocations: { clearing: allocs.clearing, hedging: allocs.hedging, insurance: allocs.insurance },
+    tradeWeight: 0,
+    totalLots: 0,
+    totalPips: 0,
+    totalTrades: 0,
+    positions: [],
+    tradeHistory: []
+  };
+}
+function useBotSimulation(options) {
+  const maxLogs = options?.maxLogs ?? 500;
+  const [logs, setLogs] = react.useState([]);
+  const [isRunning, setIsRunning] = react.useState(false);
+  const [strategies, setStrategies] = react.useState([]);
+  const [botStatesMap, setBotStatesMap] = react.useState(/* @__PURE__ */ new Map());
+  const engineRef = react.useRef(null);
+  const unsubRef = react.useRef(null);
+  const getEngine = react.useCallback(() => {
+    if (!engineRef.current) {
+      try {
+        const { botSimulationEngine: botSimulationEngine2 } = (init_BotSimulationEngine(), __toCommonJS(BotSimulationEngine_exports));
+        engineRef.current = botSimulationEngine2;
+        setStrategies(botSimulationEngine2.getStrategies());
+      } catch {
+      }
+    }
+    return engineRef.current;
+  }, []);
+  const logsByStrategy = react.useMemo(() => {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const log of logs) {
+      const existing = grouped.get(log.strategyId) || [];
+      grouped.set(log.strategyId, [...existing, log]);
+    }
+    return grouped;
+  }, [logs]);
+  const start = react.useCallback((strategyIds, userPairs, userChains) => {
+    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]);
+  const stop = react.useCallback((strategyIds) => {
+    const engine = getEngine();
+    if (engine) {
+      engine.stop(strategyIds);
+      if (!strategyIds) {
+        setIsRunning(false);
+      }
+    }
+  }, [getEngine]);
+  const clearLogs = react.useCallback(() => {
+    setLogs([]);
+  }, []);
+  const emitBootSequence = react.useCallback(() => {
+    const engine = getEngine();
+    if (engine) {
+      engine.emitBootSequence();
+    }
+  }, [getEngine]);
+  const getBotState = react.useCallback((strategyId) => {
+    return botStatesMap.get(strategyId);
+  }, [botStatesMap]);
+  react.useEffect(() => {
+    const engine = getEngine();
+    if (!engine) return;
+    setIsRunning(engine.isRunning());
+    unsubRef.current = engine.onLog((entry) => {
+      setLogs((prev) => {
+        const next = [...prev, entry];
+        return next.length > maxLogs ? next.slice(-maxLogs) : next;
+      });
+      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]);
+  react.useEffect(() => {
+    if (options?.autoStart) {
+      const engine = getEngine();
+      if (engine && !engine.isRunning()) {
+        emitBootSequence();
+        setTimeout(() => {
+          start();
+        }, 5500);
+      }
+    }
+  }, [options?.autoStart, getEngine, emitBootSequence, start]);
+  react.useEffect(() => {
+    if (!isRunning) return;
+    const interval = setInterval(() => {
+      const engine = getEngine();
+      if (engine) {
+        const states = engine.getAllBotStates();
+        if (states.size > 0) {
+          setBotStatesMap(new Map(states));
+        }
+      }
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [isRunning, getEngine]);
+  return {
+    logs,
+    logsByStrategy,
+    botStates: botStatesMap,
+    isRunning,
+    strategies,
+    start,
+    stop,
+    clearLogs,
+    emitBootSequence,
+    getBotState
+  };
+}
+var _consoleAccessToken = null;
+var _consoleEngineUrl = "https://api.one23.io";
+function setConsoleAccessToken(token) {
+  _consoleAccessToken = token;
+}
+function clearConsoleAccessToken() {
+  _consoleAccessToken = null;
+}
+function setConsoleEngineUrl(url) {
+  _consoleEngineUrl = url;
+}
+async function consoleApi(path, options) {
+  try {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (_consoleAccessToken) {
+      headers["Authorization"] = `Bearer ${_consoleAccessToken}`;
+    }
+    const res = await fetch(`${_consoleEngineUrl}${path}`, { ...options, headers });
+    if (!res.ok) return null;
+    const json = await res.json();
+    return json?.data ?? json;
+  } catch {
+    return null;
+  }
+}
+function generateSimulatedPositions(strategyIds) {
+  const strategies = [
+    { id: "balanced-01", name: "Balanced Alpha", shortName: "BAL" },
+    { id: "conservative-01", name: "Conservative Shield", shortName: "CON" },
+    { id: "aggressive-01", name: "Aggressive Momentum", shortName: "AGG" }
+  ];
+  const pairs = ["BTC/USDT", "ETH/USDT", "SOL/USDT", "ARB/USDT", "AVAX/USDT"];
+  const basePrices = {
+    "BTC/USDT": 67500,
+    "ETH/USDT": 3450,
+    "SOL/USDT": 178,
+    "ARB/USDT": 1.18,
+    "AVAX/USDT": 38.5
+  };
+  const positions = [];
+  const filteredStrategies = strategyIds ? strategies.filter((s) => strategyIds.includes(s.id)) : strategies;
+  for (const strategy of filteredStrategies) {
+    const numPositions = Math.floor(Math.random() * 4);
+    for (let i = 0; i < numPositions; i++) {
+      const pair = pairs[Math.floor(Math.random() * pairs.length)];
+      const basePrice = basePrices[pair];
+      const side = Math.random() > 0.5 ? "LONG" : "SHORT";
+      const entryPrice = basePrice * (1 + (Math.random() - 0.5) * 0.02);
+      const currentPrice = basePrice * (1 + (Math.random() - 0.5) * 0.03);
+      const leverage = Math.floor(Math.random() * 10) + 2;
+      const size = Math.floor(Math.random() * 1e3) + 100;
+      const margin = size / leverage;
+      const priceDiff = side === "LONG" ? (currentPrice - entryPrice) / entryPrice : (entryPrice - currentPrice) / entryPrice;
+      const pnlPercent = priceDiff * leverage * 100;
+      const pnl = size * priceDiff * leverage;
+      positions.push({
+        id: `pos_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        strategyId: strategy.id,
+        strategyName: strategy.name,
+        pair,
+        side,
+        entryPrice,
+        currentPrice,
+        size,
+        leverage,
+        margin,
+        pnl,
+        pnlPercent,
+        status: "open",
+        stopLoss: entryPrice * (side === "LONG" ? 0.95 : 1.05),
+        takeProfit: entryPrice * (side === "LONG" ? 1.1 : 0.9),
+        liquidationPrice: entryPrice * (side === "LONG" ? 1 - 1 / leverage : 1 + 1 / leverage),
+        openTime: Date.now() - Math.floor(Math.random() * 864e5),
+        chain: ["ethereum", "arbitrum", "base"][Math.floor(Math.random() * 3)],
+        aiConfidence: Math.random() * 0.4 + 0.5,
+        aiReasoning: `${side === "LONG" ? "Bullish" : "Bearish"} momentum detected on ${pair}`
+      });
+    }
+  }
+  return positions;
+}
+function useAIPositions(options) {
+  const [positions, setPositions] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const fetchPositions = react.useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      if (options?.simulation) {
+        const simulated = generateSimulatedPositions(options?.strategyIds);
+        setPositions(simulated);
+      } else {
+        let path = "/api/v1/ai-quant/positions";
+        const params = new URLSearchParams();
+        if (options?.strategyId) {
+          params.append("strategyId", options.strategyId);
+        }
+        if (options?.strategyIds?.length) {
+          params.append("strategyIds", options.strategyIds.join(","));
+        }
+        if (options?.status) {
+          const statuses = Array.isArray(options.status) ? options.status : [options.status];
+          params.append("status", statuses.join(","));
+        }
+        if (params.toString()) {
+          path += `?${params.toString()}`;
+        }
+        const data = await consoleApi(path);
+        if (data?.positions) {
+          setPositions(data.positions.map(mapPosition));
+        }
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to fetch positions");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [options?.simulation, options?.strategyId, options?.strategyIds, options?.status]);
+  const closePosition = react.useCallback(async (positionId) => {
+    try {
+      if (options?.simulation) {
+        setPositions((prev) => prev.map(
+          (p) => p.id === positionId ? { ...p, status: "closed", closeTime: Date.now() } : p
+        ));
+        return true;
+      }
+      await consoleApi(`/api/v1/ai-quant/positions/${positionId}/close`, { method: "POST" });
+      setPositions((prev) => prev.map(
+        (p) => p.id === positionId ? { ...p, status: "closed", closeTime: Date.now() } : p
+      ));
+      return true;
+    } catch {
+      return false;
+    }
+  }, [options?.simulation]);
+  const updateStopLoss = react.useCallback(async (positionId, stopLoss) => {
+    try {
+      if (options?.simulation) {
+        setPositions((prev) => prev.map(
+          (p) => p.id === positionId ? { ...p, stopLoss } : p
+        ));
+        return true;
+      }
+      await consoleApi(`/api/v1/ai-quant/positions/${positionId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ stopLoss })
+      });
+      setPositions((prev) => prev.map(
+        (p) => p.id === positionId ? { ...p, stopLoss } : p
+      ));
+      return true;
+    } catch {
+      return false;
+    }
+  }, [options?.simulation]);
+  const updateTakeProfit = react.useCallback(async (positionId, takeProfit) => {
+    try {
+      if (options?.simulation) {
+        setPositions((prev) => prev.map(
+          (p) => p.id === positionId ? { ...p, takeProfit } : p
+        ));
+        return true;
+      }
+      await consoleApi(`/api/v1/ai-quant/positions/${positionId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ takeProfit })
+      });
+      setPositions((prev) => prev.map(
+        (p) => p.id === positionId ? { ...p, takeProfit } : p
+      ));
+      return true;
+    } catch {
+      return false;
+    }
+  }, [options?.simulation]);
+  react.useEffect(() => {
+    fetchPositions();
+    if (options?.pollInterval) {
+      const timer = setInterval(fetchPositions, options.pollInterval);
+      return () => clearInterval(timer);
+    }
+  }, [fetchPositions, options?.pollInterval]);
+  const openPositions = react.useMemo(
+    () => positions.filter((p) => p.status === "open"),
+    [positions]
+  );
+  const closedPositions = react.useMemo(
+    () => positions.filter((p) => p.status === "closed"),
+    [positions]
+  );
+  const summary = react.useMemo(() => {
+    const open = positions.filter((p) => p.status === "open");
+    const byStrategy = {};
+    for (const pos of open) {
+      if (!byStrategy[pos.strategyId]) {
+        byStrategy[pos.strategyId] = { count: 0, pnl: 0, exposure: 0 };
+      }
+      byStrategy[pos.strategyId].count++;
+      byStrategy[pos.strategyId].pnl += pos.pnl;
+      byStrategy[pos.strategyId].exposure += pos.size;
+    }
+    const totalExposure = open.reduce((sum, p) => sum + p.size, 0);
+    const totalPnl = positions.reduce((sum, p) => sum + p.pnl, 0);
+    const unrealizedPnl = open.reduce((sum, p) => sum + p.pnl, 0);
+    const avgLeverage = open.length > 0 ? open.reduce((sum, p) => sum + p.leverage, 0) / open.length : 0;
+    return {
+      totalPositions: positions.length,
+      openCount: open.length,
+      totalExposure,
+      totalPnl,
+      unrealizedPnl,
+      avgLeverage,
+      byStrategy
+    };
+  }, [positions]);
+  return {
+    positions,
+    openPositions,
+    closedPositions,
+    isLoading,
+    error,
+    refresh: fetchPositions,
+    closePosition,
+    updateStopLoss,
+    updateTakeProfit,
+    summary
+  };
+}
+function mapPosition(raw) {
+  return {
+    id: raw.id,
+    strategyId: raw.strategyId ?? raw.strategy_id,
+    strategyName: raw.strategyName ?? raw.strategy_name ?? "",
+    pair: raw.pair,
+    side: raw.side,
+    entryPrice: raw.entryPrice ?? raw.entry_price ?? 0,
+    currentPrice: raw.currentPrice ?? raw.current_price ?? 0,
+    size: raw.size ?? 0,
+    leverage: raw.leverage ?? 1,
+    margin: raw.margin ?? raw.size / (raw.leverage ?? 1),
+    pnl: raw.pnl ?? 0,
+    pnlPercent: raw.pnlPercent ?? raw.pnl_percent ?? 0,
+    status: raw.status ?? "open",
+    stopLoss: raw.stopLoss ?? raw.stop_loss,
+    takeProfit: raw.takeProfit ?? raw.take_profit,
+    liquidationPrice: raw.liquidationPrice ?? raw.liquidation_price,
+    openTime: raw.openTime ?? raw.open_time ?? Date.now(),
+    closeTime: raw.closeTime ?? raw.close_time,
+    chain: raw.chain,
+    orderId: raw.orderId ?? raw.order_id,
+    aiConfidence: raw.aiConfidence ?? raw.ai_confidence,
+    aiReasoning: raw.aiReasoning ?? raw.ai_reasoning
+  };
+}
+function generateSimulatedDecisions(strategyIds, limit = 50) {
+  const strategies = [
+    { id: "balanced-01", name: "Balanced Alpha" },
+    { id: "conservative-01", name: "Conservative Shield" },
+    { id: "aggressive-01", name: "Aggressive Momentum" }
+  ];
+  const pairs = ["BTC/USDT", "ETH/USDT", "SOL/USDT", "ARB/USDT", "AVAX/USDT"];
+  const actions = ["OPEN_LONG", "OPEN_SHORT", "CLOSE_LONG", "CLOSE_SHORT", "HOLD", "SKIP"];
+  const reasonings = {
+    OPEN_LONG: [
+      "RSI oversold with MACD bullish crossover",
+      "Golden cross detected on EMA, volume confirming",
+      "Support level held, momentum building",
+      "Bullish divergence on RSI, trend reversal likely"
+    ],
+    OPEN_SHORT: [
+      "RSI overbought with MACD bearish crossover",
+      "Death cross on EMA, volume increasing",
+      "Resistance level rejected, bearish pressure",
+      "Bearish divergence detected, reversal expected"
+    ],
+    CLOSE_LONG: [
+      "Take profit target reached",
+      "Momentum weakening, securing profits",
+      "Risk management triggered"
+    ],
+    CLOSE_SHORT: [
+      "Take profit target reached",
+      "Bearish momentum exhausted",
+      "Stop loss proximity warning"
+    ],
+    HOLD: [
+      "No clear signal, waiting for confirmation",
+      "Consolidation phase, insufficient momentum",
+      "Mixed indicators, patience advised"
+    ],
+    SKIP: [
+      "Confidence below threshold",
+      "Risk parameters exceeded",
+      "Position limit reached"
+    ]
+  };
+  const filteredStrategies = strategyIds ? strategies.filter((s) => strategyIds.includes(s.id)) : strategies;
+  const decisions = [];
+  const now = Date.now();
+  for (let i = 0; i < limit; i++) {
+    const strategy = filteredStrategies[Math.floor(Math.random() * filteredStrategies.length)];
+    const pair = pairs[Math.floor(Math.random() * pairs.length)];
+    const action = actions[Math.floor(Math.random() * actions.length)];
+    const confidence = Math.random() * 0.5 + 0.3;
+    const executed = action !== "HOLD" && action !== "SKIP" && confidence > 0.5;
+    const reasoningList = reasonings[action];
+    decisions.push({
+      id: `dec_${now - i * 6e4}_${Math.random().toString(36).slice(2, 8)}`,
+      timestamp: now - i * (Math.random() * 3e5 + 6e4),
+      strategyId: strategy.id,
+      strategyName: strategy.name,
+      pair,
+      action,
+      confidence,
+      reasoning: reasoningList[Math.floor(Math.random() * reasoningList.length)],
+      indicators: {
+        rsi: Math.random() * 100,
+        macd: (Math.random() - 0.5) * 2,
+        ema: Math.random() > 0.5 ? "bullish" : "bearish",
+        volume: Math.random() * 2 + 0.5,
+        bollinger: Math.random() > 0.5 ? "upper" : "lower"
+      },
+      signals: [
+        `RSI ${Math.random() > 0.5 ? "oversold" : "overbought"}`,
+        `MACD ${Math.random() > 0.5 ? "bullish" : "bearish"}`
+      ],
+      executed,
+      positionId: executed ? `pos_${Date.now()}_${Math.random().toString(36).slice(2, 6)}` : void 0,
+      price: 5e4 * (1 + (Math.random() - 0.5) * 0.1),
+      size: executed ? Math.floor(Math.random() * 1e3) + 100 : void 0,
+      leverage: executed ? Math.floor(Math.random() * 10) + 2 : void 0
+    });
+  }
+  return decisions.sort((a, b) => b.timestamp - a.timestamp);
+}
+function useAIDecisions(options) {
+  const limit = options?.limit ?? 100;
+  const [decisions, setDecisions] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const fetchDecisions = react.useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      if (options?.simulation) {
+        const simulated = generateSimulatedDecisions(options?.strategyIds, limit);
+        setDecisions(simulated);
+      } else {
+        let path = "/api/v1/ai-quant/decisions";
+        const params = new URLSearchParams();
+        if (options?.strategyId) {
+          params.append("strategyId", options.strategyId);
+        }
+        if (options?.strategyIds?.length) {
+          params.append("strategyIds", options.strategyIds.join(","));
+        }
+        if (options?.actions?.length) {
+          params.append("actions", options.actions.join(","));
+        }
+        params.append("limit", limit.toString());
+        if (params.toString()) {
+          path += `?${params.toString()}`;
+        }
+        const res = await fetch(`https://api.one23.io${path}`);
+        if (res.ok) {
+          const data = await res.json();
+          if (data?.decisions) {
+            setDecisions(data.decisions.map(mapDecision));
+          }
+        }
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to fetch decisions");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [options?.simulation, options?.strategyId, options?.strategyIds, options?.actions, limit]);
+  react.useEffect(() => {
+    fetchDecisions();
+    if (options?.pollInterval) {
+      const timer = setInterval(fetchDecisions, options.pollInterval);
+      return () => clearInterval(timer);
+    }
+  }, [fetchDecisions, options?.pollInterval]);
+  const getByStrategy = react.useCallback(
+    (strategyId) => decisions.filter((d) => d.strategyId === strategyId),
+    [decisions]
+  );
+  const getByAction = react.useCallback(
+    (action) => decisions.filter((d) => d.action === action),
+    [decisions]
+  );
+  const recentDecisions = react.useMemo(
+    () => decisions.slice(0, 10),
+    [decisions]
+  );
+  const executedDecisions = react.useMemo(
+    () => decisions.filter((d) => d.executed),
+    [decisions]
+  );
+  const stats = react.useMemo(() => {
+    const executed = decisions.filter((d) => d.executed);
+    const byAction = {
+      OPEN_LONG: 0,
+      OPEN_SHORT: 0,
+      CLOSE_LONG: 0,
+      CLOSE_SHORT: 0,
+      HOLD: 0,
+      SKIP: 0
+    };
+    const byStrategy = {};
+    for (const d of decisions) {
+      byAction[d.action]++;
+      byStrategy[d.strategyId] = (byStrategy[d.strategyId] || 0) + 1;
+    }
+    const avgConfidence = decisions.length > 0 ? decisions.reduce((sum, d) => sum + d.confidence, 0) / decisions.length : 0;
+    return {
+      totalDecisions: decisions.length,
+      executedCount: executed.length,
+      executionRate: decisions.length > 0 ? executed.length / decisions.length : 0,
+      byAction,
+      byStrategy,
+      avgConfidence
+    };
+  }, [decisions]);
+  return {
+    decisions,
+    recentDecisions,
+    executedDecisions,
+    isLoading,
+    error,
+    refresh: fetchDecisions,
+    getByStrategy,
+    getByAction,
+    stats
+  };
+}
+function mapDecision(raw) {
+  return {
+    id: raw.id,
+    timestamp: raw.timestamp ?? Date.now(),
+    strategyId: raw.strategyId ?? raw.strategy_id,
+    strategyName: raw.strategyName ?? raw.strategy_name ?? "",
+    pair: raw.pair,
+    action: raw.action,
+    confidence: raw.confidence ?? 0,
+    reasoning: raw.reasoning ?? "",
+    indicators: raw.indicators ?? {},
+    signals: raw.signals ?? [],
+    executed: raw.executed ?? false,
+    positionId: raw.positionId ?? raw.position_id,
+    price: raw.price,
+    size: raw.size,
+    leverage: raw.leverage
+  };
+}
+
+// src/types/console.ts
+var DEFAULT_RISK_STATUS = {
+  timestamp: Date.now(),
+  totalExposure: 0,
+  maxExposure: 1e5,
+  exposurePercent: 0,
+  dailyPnl: 0,
+  dailyPnlLimit: 5e3,
+  dailyPnlPercent: 0,
+  dailyTradeCount: 0,
+  dailyTradeLimit: 50,
+  currentDrawdown: 0,
+  maxDrawdown: 15,
+  drawdownPercent: 0,
+  openPositions: 0,
+  maxPositions: 10,
+  riskLevel: "low",
+  tradingStatus: "active",
+  warnings: []
+};
+function calculateRiskLevel(exposurePercent, drawdownPercent, dailyPnlPercent) {
+  const worstMetric = Math.max(exposurePercent, drawdownPercent, Math.abs(dailyPnlPercent));
+  if (worstMetric >= 90) return "critical";
+  if (worstMetric >= 70) return "high";
+  if (worstMetric >= 40) return "medium";
+  return "low";
+}
+
+// src/hooks/useAIRiskStatus.ts
+function generateSimulatedRiskStatus() {
+  const totalExposure = Math.random() * 8e4 + 1e4;
+  const maxExposure = 1e5;
+  const exposurePercent = totalExposure / maxExposure * 100;
+  const dailyPnl = (Math.random() - 0.3) * 3e3;
+  const dailyPnlLimit = 5e3;
+  const dailyPnlPercent = Math.abs(dailyPnl) / dailyPnlLimit * 100;
+  const currentDrawdown = Math.random() * 10;
+  const maxDrawdown = 15;
+  const drawdownPercent = currentDrawdown / maxDrawdown * 100;
+  const openPositions = Math.floor(Math.random() * 8);
+  const maxPositions = 10;
+  const dailyTradeCount = Math.floor(Math.random() * 30);
+  const dailyTradeLimit = 50;
+  const riskLevel = calculateRiskLevel(exposurePercent, drawdownPercent, dailyPnlPercent);
+  const warnings = [];
+  if (exposurePercent > 70) warnings.push("High portfolio exposure");
+  if (drawdownPercent > 60) warnings.push("Approaching max drawdown");
+  if (dailyPnlPercent > 80 && dailyPnl < 0) warnings.push("Daily loss limit warning");
+  if (openPositions >= maxPositions - 1) warnings.push("Position limit nearly reached");
+  let tradingStatus = "active";
+  if (riskLevel === "critical") tradingStatus = "stopped";
+  else if (riskLevel === "high" && warnings.length > 1) tradingStatus = "paused";
+  const strategyRisks = {
+    "balanced-01": {
+      exposure: Math.random() * 3e4,
+      drawdown: Math.random() * 5,
+      riskLevel: Math.random() > 0.7 ? "medium" : "low"
+    },
+    "conservative-01": {
+      exposure: Math.random() * 2e4,
+      drawdown: Math.random() * 3,
+      riskLevel: "low"
+    },
+    "aggressive-01": {
+      exposure: Math.random() * 4e4,
+      drawdown: Math.random() * 8,
+      riskLevel: Math.random() > 0.5 ? "high" : "medium"
+    }
+  };
+  return {
+    timestamp: Date.now(),
+    totalExposure,
+    maxExposure,
+    exposurePercent,
+    dailyPnl,
+    dailyPnlLimit,
+    dailyPnlPercent,
+    dailyTradeCount,
+    dailyTradeLimit,
+    currentDrawdown,
+    maxDrawdown,
+    drawdownPercent,
+    openPositions,
+    maxPositions,
+    riskLevel,
+    tradingStatus,
+    warnings,
+    strategyRisks
+  };
+}
+function useAIRiskStatus(options) {
+  const [riskStatus, setRiskStatus] = react.useState(DEFAULT_RISK_STATUS);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const fetchRiskStatus = react.useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      if (options?.simulation) {
+        const simulated = generateSimulatedRiskStatus();
+        setRiskStatus(simulated);
+      } else {
+        let path = "/api/v1/ai-quant/risk-status";
+        if (options?.strategyId) {
+          path += `?strategyId=${options.strategyId}`;
+        }
+        const res = await fetch(`https://api.one23.io${path}`);
+        if (res.ok) {
+          const data = await res.json();
+          if (data) {
+            setRiskStatus(mapRiskStatus(data));
+          }
+        }
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to fetch risk status");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [options?.simulation, options?.strategyId]);
+  react.useEffect(() => {
+    fetchRiskStatus();
+    if (options?.pollInterval) {
+      const timer = setInterval(fetchRiskStatus, options.pollInterval);
+      return () => clearInterval(timer);
+    }
+  }, [fetchRiskStatus, options?.pollInterval]);
+  const pauseTrading = react.useCallback(async () => {
+    try {
+      if (options?.simulation) {
+        setRiskStatus((prev) => ({ ...prev, tradingStatus: "paused" }));
+        return true;
+      }
+      const res = await fetch("https://api.one23.io/api/v1/ai-quant/trading/pause", {
+        method: "POST"
+      });
+      if (res.ok) {
+        setRiskStatus((prev) => ({ ...prev, tradingStatus: "paused" }));
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }, [options?.simulation]);
+  const resumeTrading = react.useCallback(async () => {
+    try {
+      if (options?.simulation) {
+        setRiskStatus((prev) => ({ ...prev, tradingStatus: "active" }));
+        return true;
+      }
+      const res = await fetch("https://api.one23.io/api/v1/ai-quant/trading/resume", {
+        method: "POST"
+      });
+      if (res.ok) {
+        setRiskStatus((prev) => ({ ...prev, tradingStatus: "active" }));
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }, [options?.simulation]);
+  const resetDailyLimits = react.useCallback(async () => {
+    try {
+      if (options?.simulation) {
+        setRiskStatus((prev) => ({
+          ...prev,
+          dailyPnl: 0,
+          dailyPnlPercent: 0,
+          dailyTradeCount: 0,
+          warnings: prev.warnings.filter((w) => !w.includes("Daily"))
+        }));
+        return true;
+      }
+      const res = await fetch("https://api.one23.io/api/v1/ai-quant/risk/reset-daily", {
+        method: "POST"
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }, [options?.simulation]);
+  const isWithinLimits = react.useMemo(() => {
+    return riskStatus.exposurePercent < 90 && riskStatus.drawdownPercent < 90 && riskStatus.dailyPnlPercent < 90 && riskStatus.openPositions < riskStatus.maxPositions;
+  }, [riskStatus]);
+  const canTrade = react.useMemo(() => {
+    return riskStatus.tradingStatus === "active" && isWithinLimits;
+  }, [riskStatus.tradingStatus, isWithinLimits]);
+  return {
+    riskStatus,
+    isLoading,
+    error,
+    refresh: fetchRiskStatus,
+    isWithinLimits,
+    canTrade,
+    riskLevel: riskStatus.riskLevel,
+    tradingStatus: riskStatus.tradingStatus,
+    warnings: riskStatus.warnings,
+    pauseTrading,
+    resumeTrading,
+    resetDailyLimits
+  };
+}
+function mapRiskStatus(raw) {
+  const exposurePercent = raw.maxExposure > 0 ? raw.totalExposure / raw.maxExposure * 100 : 0;
+  const dailyPnlPercent = raw.dailyPnlLimit > 0 ? Math.abs(raw.dailyPnl) / raw.dailyPnlLimit * 100 : 0;
+  const drawdownPercent = raw.maxDrawdown > 0 ? raw.currentDrawdown / raw.maxDrawdown * 100 : 0;
+  return {
+    timestamp: raw.timestamp ?? Date.now(),
+    totalExposure: raw.totalExposure ?? raw.total_exposure ?? 0,
+    maxExposure: raw.maxExposure ?? raw.max_exposure ?? 1e5,
+    exposurePercent,
+    dailyPnl: raw.dailyPnl ?? raw.daily_pnl ?? 0,
+    dailyPnlLimit: raw.dailyPnlLimit ?? raw.daily_pnl_limit ?? 5e3,
+    dailyPnlPercent,
+    dailyTradeCount: raw.dailyTradeCount ?? raw.daily_trade_count ?? 0,
+    dailyTradeLimit: raw.dailyTradeLimit ?? raw.daily_trade_limit ?? 50,
+    currentDrawdown: raw.currentDrawdown ?? raw.current_drawdown ?? 0,
+    maxDrawdown: raw.maxDrawdown ?? raw.max_drawdown ?? 15,
+    drawdownPercent,
+    openPositions: raw.openPositions ?? raw.open_positions ?? 0,
+    maxPositions: raw.maxPositions ?? raw.max_positions ?? 10,
+    riskLevel: raw.riskLevel ?? raw.risk_level ?? calculateRiskLevel(exposurePercent, drawdownPercent, dailyPnlPercent),
+    tradingStatus: raw.tradingStatus ?? raw.trading_status ?? "active",
+    warnings: raw.warnings ?? [],
+    strategyRisks: raw.strategyRisks ?? raw.strategy_risks
+  };
+}
+
+// src/hooks/useAIQuantConsole.ts
+function useAIQuantConsole(options) {
+  const simulation = options?.simulation ?? true;
+  const pollInterval = options?.pollInterval ?? 5e3;
+  const maxLogs = options?.maxLogs ?? 500;
+  const strategyIds = options?.strategyIds;
+  const botSim = useBotSimulation({
+    maxLogs,
+    strategyIds,
+    autoStart: false
+  });
+  const positionsHook = useAIPositions({
+    strategyIds,
+    pollInterval,
+    simulation
+  });
+  const decisionsHook = useAIDecisions({
+    strategyIds,
+    pollInterval,
+    simulation,
+    limit: 100
+  });
+  const riskHook = useAIRiskStatus({
+    pollInterval,
+    simulation
+  });
+  const agents = react.useMemo(() => {
+    const agentList = [];
+    for (const strategy of botSim.strategies) {
+      const state = botSim.botStates.get(strategy.id);
+      const strategyPositions = positionsHook.positions.filter((p) => p.strategyId === strategy.id);
+      decisionsHook.decisions.filter((d) => d.strategyId === strategy.id);
+      const openPos = strategyPositions.filter((p) => p.status === "open");
+      const totalPnl = strategyPositions.reduce((sum, p) => sum + p.pnl, 0);
+      const exposure = openPos.reduce((sum, p) => sum + p.size, 0);
+      const winCount = strategyPositions.filter((p) => p.pnl > 0).length;
+      const totalTrades = strategyPositions.length;
+      let riskLevel = "low";
+      if (strategy.riskTolerance === "high") riskLevel = "medium";
+      if (exposure > 5e4) riskLevel = "high";
+      if (state && state.openPositions.length >= 3) riskLevel = "high";
+      agentList.push({
+        id: strategy.id,
+        strategyId: strategy.id,
+        name: strategy.name,
+        shortName: strategy.shortName,
+        color: strategy.color,
+        status: state?.isRunning ? "active" : botSim.isRunning ? "idle" : "paused",
+        totalPnl: state?.totalPnl ?? totalPnl,
+        pnlToday: totalPnl * 0.3,
+        // Simulated
+        winRate: state?.winRate ?? (totalTrades > 0 ? winCount / totalTrades : 0.5),
+        totalTrades: state?.totalTrades ?? totalTrades,
+        tradesToday: Math.floor((state?.totalTrades ?? totalTrades) * 0.2),
+        currentPair: state?.currentPair,
+        currentPrice: state?.currentPrice,
+        lastSignal: state?.lastSignal,
+        lastSignalConfidence: state?.lastSignalConfidence,
+        lastActivity: state ? Date.now() : void 0,
+        openPositions: openPos.length,
+        totalExposure: exposure,
+        riskLevel,
+        drawdown: Math.random() * 5,
+        // Simulated
+        riskTolerance: strategy.riskTolerance,
+        primaryIndicators: strategy.primaryIndicators,
+        preferredPairs: strategy.preferredPairs,
+        leverageRange: [strategy.leverageMin, strategy.leverageMax]
+      });
+    }
+    return agentList;
+  }, [botSim.strategies, botSim.botStates, botSim.isRunning, positionsHook.positions, decisionsHook.decisions]);
+  const metrics = react.useMemo(() => {
+    const positions = positionsHook.positions;
+    const openPos = positions.filter((p) => p.status === "open");
+    const closedPos = positions.filter((p) => p.status === "closed");
+    const totalPnl = positions.reduce((sum, p) => sum + p.pnl, 0);
+    const unrealizedPnl = openPos.reduce((sum, p) => sum + p.pnl, 0);
+    const realizedPnl = closedPos.reduce((sum, p) => sum + p.pnl, 0);
+    const wins = positions.filter((p) => p.pnl > 0);
+    const losses = positions.filter((p) => p.pnl < 0);
+    const avgWin = wins.length > 0 ? wins.reduce((sum, p) => sum + p.pnl, 0) / wins.length : 0;
+    const avgLoss = losses.length > 0 ? Math.abs(losses.reduce((sum, p) => sum + p.pnl, 0)) / losses.length : 0;
+    const profitFactor = avgLoss > 0 ? avgWin / avgLoss : avgWin > 0 ? Infinity : 0;
+    const totalExposure = openPos.reduce((sum, p) => sum + p.size, 0);
+    const avgLeverage = openPos.length > 0 ? openPos.reduce((sum, p) => sum + p.leverage, 0) / openPos.length : 0;
+    const strategyMetrics = {};
+    for (const agent of agents) {
+      const strategyPos = positions.filter((p) => p.strategyId === agent.strategyId);
+      const strategyOpen = strategyPos.filter((p) => p.status === "open");
+      const strategyWins = strategyPos.filter((p) => p.pnl > 0);
+      strategyMetrics[agent.strategyId] = {
+        pnl: strategyPos.reduce((sum, p) => sum + p.pnl, 0),
+        trades: strategyPos.length,
+        winRate: strategyPos.length > 0 ? strategyWins.length / strategyPos.length : 0,
+        exposure: strategyOpen.reduce((sum, p) => sum + p.size, 0)
+      };
+    }
+    return {
+      nav: 1e5 + totalPnl,
+      navChange24h: totalPnl * 0.3,
+      navChangePercent24h: totalPnl * 0.3 / 1e5 * 100,
+      totalPnl,
+      realizedPnl,
+      unrealizedPnl,
+      pnlToday: totalPnl * 0.3,
+      pnl7d: totalPnl * 0.7,
+      pnl30d: totalPnl,
+      totalTrades: positions.length,
+      tradesToday: Math.floor(positions.length * 0.2),
+      winRate: positions.length > 0 ? wins.length / positions.length : 0,
+      winCount: wins.length,
+      lossCount: losses.length,
+      avgWin,
+      avgLoss,
+      profitFactor,
+      openPositions: openPos.length,
+      totalExposure,
+      avgLeverage,
+      strategyMetrics
+    };
+  }, [positionsHook.positions, agents]);
+  const start = react.useCallback((ids) => {
+    botSim.start(ids || strategyIds);
+  }, [botSim, strategyIds]);
+  const stop = react.useCallback((ids) => {
+    botSim.stop(ids);
+  }, [botSim]);
+  const clearLogs = react.useCallback(() => {
+    botSim.clearLogs();
+  }, [botSim]);
+  const refresh = react.useCallback(async () => {
+    await Promise.all([
+      positionsHook.refresh(),
+      decisionsHook.refresh(),
+      riskHook.refresh()
+    ]);
+  }, [positionsHook, decisionsHook, riskHook]);
+  const getAgent = react.useCallback(
+    (strategyId) => agents.find((a) => a.strategyId === strategyId),
+    [agents]
+  );
+  const getAgentLogs = react.useCallback(
+    (strategyId) => botSim.logsByStrategy.get(strategyId) || [],
+    [botSim.logsByStrategy]
+  );
+  const getAgentPositions = react.useCallback(
+    (strategyId) => positionsHook.positions.filter((p) => p.strategyId === strategyId),
+    [positionsHook.positions]
+  );
+  const getAgentDecisions = react.useCallback(
+    (strategyId) => decisionsHook.decisions.filter((d) => d.strategyId === strategyId),
+    [decisionsHook.decisions]
+  );
+  const isLoading = positionsHook.isLoading || decisionsHook.isLoading || riskHook.isLoading;
+  const error = positionsHook.error || decisionsHook.error || riskHook.error;
+  return {
+    strategies: botSim.strategies,
+    agents,
+    logs: botSim.logs,
+    logsByStrategy: botSim.logsByStrategy,
+    botStates: botSim.botStates,
+    positions: positionsHook.positions,
+    openPositions: positionsHook.openPositions,
+    decisions: decisionsHook.decisions,
+    recentDecisions: decisionsHook.recentDecisions,
+    riskStatus: riskHook.riskStatus,
+    metrics,
+    isRunning: botSim.isRunning,
+    isLoading,
+    error,
+    start,
+    stop,
+    clearLogs,
+    emitBootSequence: botSim.emitBootSequence,
+    refresh,
+    getAgent,
+    getAgentLogs,
+    getAgentPositions,
+    getAgentDecisions
+  };
+}
+
+// src/hooks/useTradingConsole.ts
+function useTradingConsole(options) {
+  const simulation = options?.simulation ?? true;
+  const pollInterval = options?.pollInterval ?? 5e3;
+  const maxLogs = options?.maxLogs ?? 500;
+  const strategyIds = options?.strategyIds;
+  const autoStart = options?.autoStart ?? false;
+  const aiConsole = useAIQuantConsole({
+    simulation,
+    pollInterval,
+    maxLogs,
+    strategyIds
+  });
+  const forexSim = useForexSimulation({ maxLogs });
+  const forexPools = useForexPools({ refreshInterval: pollInterval });
+  const forexInvestments = useForexInvestments({ refreshInterval: pollInterval });
+  const combinedLogs = react.useMemo(() => {
+    const combined = [];
+    for (const log of aiConsole.logs) {
+      combined.push({
+        id: log.id,
+        timestamp: log.timestamp,
+        source: "ai",
+        strategyId: log.strategyId,
+        strategyName: log.strategyName,
+        type: log.type,
+        message: log.message,
+        data: log.data,
+        importance: log.importance
+      });
+    }
+    for (const log of forexSim.logs) {
+      combined.push({
+        id: log.id,
+        timestamp: log.timestamp,
+        source: "forex",
+        type: log.type,
+        message: log.message,
+        data: log.data,
+        importance: log.importance
+      });
+    }
+    return combined.sort((a, b) => b.timestamp - a.timestamp).slice(0, maxLogs);
+  }, [aiConsole.logs, forexSim.logs, maxLogs]);
+  const combinedMetrics = react.useMemo(() => {
+    const aiMetrics = aiConsole.metrics;
+    return {
+      ...aiMetrics,
+      totalPnl: aiMetrics.totalPnl + forexSim.stats.totalPnl,
+      totalTrades: aiMetrics.totalTrades + forexSim.stats.totalTrades
+    };
+  }, [aiConsole.metrics, forexSim.stats]);
+  const controls = react.useMemo(() => ({
+    startAISimulation: (ids) => {
+      aiConsole.emitBootSequence();
+      setTimeout(() => aiConsole.start(ids), 5500);
+    },
+    stopAISimulation: (ids) => {
+      aiConsole.stop(ids);
+    },
+    startForexSimulation: () => {
+      forexSim.start();
+    },
+    stopForexSimulation: () => {
+      forexSim.stop();
+    },
+    startAll: () => {
+      aiConsole.emitBootSequence();
+      setTimeout(() => {
+        aiConsole.start();
+        forexSim.start();
+      }, 5500);
+    },
+    stopAll: () => {
+      aiConsole.stop();
+      forexSim.stop();
+    },
+    clearLogs: () => {
+      aiConsole.clearLogs();
+      forexSim.clearLogs();
+    },
+    emitBootSequence: () => {
+      aiConsole.emitBootSequence();
+    },
+    refreshAll: async () => {
+      await Promise.all([
+        aiConsole.refresh(),
+        forexPools.refresh(),
+        forexInvestments.refresh()
+      ]);
+    }
+  }), [aiConsole, forexSim, forexPools, forexInvestments]);
+  const state = react.useMemo(() => ({
+    isAISimulationRunning: aiConsole.isRunning,
+    isForexSimulationRunning: forexSim.isRunning,
+    isAnyRunning: aiConsole.isRunning || forexSim.isRunning,
+    isLoading: aiConsole.isLoading || forexPools.isLoading || forexInvestments.isLoading,
+    error: aiConsole.error || forexPools.error || forexInvestments.error
+  }), [aiConsole.isRunning, aiConsole.isLoading, aiConsole.error, forexSim.isRunning, forexPools, forexInvestments]);
+  react.useEffect(() => {
+    if (autoStart) {
+      controls.startAll();
+    }
+  }, [autoStart, controls]);
+  return {
+    ai: {
+      strategies: aiConsole.strategies,
+      agents: aiConsole.agents,
+      positions: aiConsole.positions,
+      decisions: aiConsole.decisions,
+      riskStatus: aiConsole.riskStatus,
+      simulationLogs: aiConsole.logs,
+      logsByStrategy: aiConsole.logsByStrategy,
+      botStates: aiConsole.botStates
+    },
+    forex: {
+      logs: forexSim.logs,
+      poolTransactions: forexSim.poolTransactions,
+      pools: forexPools.pools,
+      investments: forexInvestments.investments,
+      stats: forexSim.stats
+    },
+    combinedLogs,
+    metrics: combinedMetrics,
+    controls,
+    state,
+    getAgent: aiConsole.getAgent,
+    getAgentLogs: aiConsole.getAgentLogs,
+    getAgentPositions: aiConsole.getAgentPositions,
+    getAgentDecisions: aiConsole.getAgentDecisions
+  };
+}
 
 exports.clearAITradingAccessToken = clearAITradingAccessToken;
+exports.clearConsoleAccessToken = clearConsoleAccessToken;
+exports.clearForexAccessToken = clearForexAccessToken;
 exports.setAITradingAccessToken = setAITradingAccessToken;
+exports.setConsoleAccessToken = setConsoleAccessToken;
+exports.setConsoleEngineUrl = setConsoleEngineUrl;
+exports.setForexAccessToken = setForexAccessToken;
+exports.setForexEngineUrl = setForexEngineUrl;
+exports.useAIAgent = useAIAgent;
+exports.useAIAgentSubscription = useAIAgentSubscription;
+exports.useAIAgents = useAIAgents;
+exports.useAIDecisions = useAIDecisions;
 exports.useAIMarketData = useAIMarketData;
 exports.useAIOrders = useAIOrders;
 exports.useAIPortfolio = useAIPortfolio;
+exports.useAIPositions = useAIPositions;
+exports.useAIQuantConsole = useAIQuantConsole;
+exports.useAIRiskStatus = useAIRiskStatus;
 exports.useAIStrategies = useAIStrategies;
 exports.useAIStrategy = useAIStrategy;
 exports.useAITrading = useAITrading;
+exports.useBotSimulation = useBotSimulation;
+exports.useForexInvestments = useForexInvestments;
+exports.useForexPoolData = useForexPoolData;
+exports.useForexPools = useForexPools;
+exports.useForexSimulation = useForexSimulation;
+exports.useForexTrading = useForexTrading;
 exports.useTokenPrice = useTokenPrice;
 exports.useTokenPrices = useTokenPrices;
+exports.useTradingConsole = useTradingConsole;
 exports.useWalletBalance = useWalletBalance;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map