@one_deploy/sdk 1.0.6 → 1.2.0

package/dist/react-native.mjs

@@ -1,5 +1,930 @@
-import { StyleSheet, View, Text, TouchableOpacity } from 'react-native';
+import { StyleSheet, Platform, View, Text, TouchableOpacity, ScrollView } from 'react-native';
 import { jsxs, jsx } from 'react/jsx-runtime';
+import { useRef, useEffect, useState, useCallback, useMemo } from '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 pick2(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 formatDate2(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 = pick2(["clearing", "hedging", "insurance"]);
+            const toOptions = ["clearing", "hedging", "insurance"].filter((p) => p !== fromPool);
+            const toPool = pick2(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 = pick2(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 === pick2(selectedPairs)) || pick2(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: formatDate2(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 pick3(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 = pick3(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 = pick3(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] ${pick3(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/config/index.ts
 var DEFAULT_ENGINE_URL = "https://api.one23.io";
@@ -120,6 +1045,189 @@ var CHAIN_CONFIGS = {
   }
 };
 
+// src/types/aiTrading.ts
+var PENALTY_TIERS = [
+  { minProgress: 0.75, maxProgress: 1, rate: 0.5, label: "50%" },
+  { minProgress: 0.5, maxProgress: 0.75, rate: 0.6, label: "60%" },
+  { minProgress: 0.25, maxProgress: 0.5, rate: 0.7, label: "70%" },
+  { minProgress: 0, maxProgress: 0.25, rate: 0.8, label: "80%" }
+];
+function calculateEarlyWithdrawalPenalty(investedAmount, profit, lockProgress) {
+  const totalValue = investedAmount + profit;
+  const isEarlyWithdrawal = lockProgress < 1;
+  let penaltyRate = 0;
+  if (isEarlyWithdrawal) {
+    if (lockProgress >= 0.75) penaltyRate = 0.5;
+    else if (lockProgress >= 0.5) penaltyRate = 0.6;
+    else if (lockProgress >= 0.25) penaltyRate = 0.7;
+    else penaltyRate = 0.8;
+  }
+  const estimatedPenalty = totalValue * penaltyRate;
+  const estimatedRedemption = totalValue - estimatedPenalty;
+  return { completionRate: lockProgress, penaltyRate, estimatedPenalty, estimatedRedemption, isEarlyWithdrawal };
+}
+var STRATEGY_CATEGORIES = {
+  conservative: { labelKey: "ai.category_conservative", color: "#10B981", icon: "\u{1F6E1}\uFE0F" },
+  balanced: { labelKey: "ai.category_balanced", color: "#3B82F6", icon: "\u2696\uFE0F" },
+  aggressive: { labelKey: "ai.category_aggressive", color: "#EF4444", icon: "\u{1F680}" },
+  hedge: { labelKey: "ai.category_hedge", color: "#8B5CF6", icon: "\u{1F512}" },
+  arbitrage: { labelKey: "ai.category_arbitrage", color: "#F59E0B", icon: "\u26A1" },
+  trend: { labelKey: "ai.category_trend", color: "#EC4899", icon: "\u{1F4C8}" },
+  grid: { labelKey: "ai.category_grid", color: "#6366F1", icon: "\u25A6" },
+  dca: { labelKey: "ai.category_dca", color: "#14B8A6", icon: "\u{1F4CA}" }
+};
+var RISK_LEVELS = {
+  1: { labelKey: "ai.risk_very_low", color: "#10B981", bgColor: "#D1FAE5" },
+  2: { labelKey: "ai.risk_low", color: "#22C55E", bgColor: "#DCFCE7" },
+  3: { labelKey: "ai.risk_medium", color: "#F59E0B", bgColor: "#FEF3C7" },
+  4: { labelKey: "ai.risk_high", color: "#F97316", bgColor: "#FFEDD5" },
+  5: { labelKey: "ai.risk_very_high", color: "#EF4444", bgColor: "#FEE2E2" }
+};
+var ORDER_STATUS_CONFIG = {
+  pending: { labelKey: "ai.status_pending", color: "#F59E0B", bgColor: "#FEF3C7" },
+  active: { labelKey: "ai.status_active", color: "#10B981", bgColor: "#D1FAE5" },
+  paused: { labelKey: "ai.status_paused", color: "#6B7280", bgColor: "#F3F4F6" },
+  completed: { labelKey: "ai.status_completed", color: "#3B82F6", bgColor: "#DBEAFE" },
+  cancelled: { labelKey: "ai.status_cancelled", color: "#EF4444", bgColor: "#FEE2E2" },
+  pending_redemption: { labelKey: "ai.status_pending_redemption", color: "#8B5CF6", bgColor: "#EDE9FE" },
+  redeemed: { labelKey: "ai.status_redeemed", color: "#14B8A6", bgColor: "#CCFBF1" }
+};
+
+// src/types/console.ts
+var AI_LOG_COLORS = {
+  SCAN: "#06B6D4",
+  // Cyan
+  THINKING: "#A855F7",
+  // Purple
+  INDICATOR: "#3B82F6",
+  // Blue
+  ANALYSIS: "#6366F1",
+  // Indigo
+  SIGNAL: "#F59E0B",
+  // Amber
+  STRATEGY: "#D946EF",
+  // Fuchsia
+  DECISION: "#F97316",
+  // Orange
+  ORDER: "#EC4899",
+  // Pink
+  FILLED: "#10B981",
+  // Green
+  PNL: "#22C55E",
+  // Emerald
+  RISK: "#EF4444",
+  // Red
+  NEWS: "#14B8A6",
+  // Teal
+  SYSTEM: "#9CA3AF"
+  // Gray
+};
+var FOREX_LOG_COLORS = {
+  RFQ: "#06B6D4",
+  // Cyan
+  QUOTE: "#8B5CF6",
+  // Purple
+  MATCH: "#10B981",
+  // Green
+  SETTLE: "#F59E0B",
+  // Amber
+  PVP: "#3B82F6",
+  // Blue
+  HEDGE: "#EC4899",
+  // Pink
+  CLEAR: "#14B8A6",
+  // Teal
+  POSITION: "#6366F1",
+  // Indigo
+  PNL: "#22C55E",
+  // Emerald
+  SYSTEM: "#9CA3AF"
+  // Gray
+};
+var RISK_LEVEL_COLORS = {
+  low: { color: "#10B981", bgColor: "#D1FAE5" },
+  medium: { color: "#F59E0B", bgColor: "#FEF3C7" },
+  high: { color: "#F97316", bgColor: "#FFEDD5" },
+  critical: { color: "#EF4444", bgColor: "#FEE2E2" }
+};
+var TRADING_STATUS_COLORS = {
+  active: { color: "#10B981", bgColor: "#D1FAE5" },
+  paused: { color: "#F59E0B", bgColor: "#FEF3C7" },
+  stopped: { color: "#EF4444", bgColor: "#FEE2E2" },
+  cooldown: { color: "#6366F1", bgColor: "#E0E7FF" }
+};
+var AGENT_STATUS_COLORS = {
+  active: { color: "#10B981", bgColor: "#D1FAE5", label: "Active" },
+  paused: { color: "#F59E0B", bgColor: "#FEF3C7", label: "Paused" },
+  idle: { color: "#6B7280", bgColor: "#F3F4F6", label: "Idle" },
+  error: { color: "#EF4444", bgColor: "#FEE2E2", label: "Error" },
+  initializing: { color: "#3B82F6", bgColor: "#DBEAFE", label: "Starting" }
+};
+var DEFAULT_CONSOLE_OPTIONS = {
+  simulation: true,
+  pollInterval: 5e3,
+  maxLogs: 500,
+  autoStart: false
+};
+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: []
+};
+var DEFAULT_CONSOLE_METRICS = {
+  nav: 0,
+  navChange24h: 0,
+  navChangePercent24h: 0,
+  totalPnl: 0,
+  realizedPnl: 0,
+  unrealizedPnl: 0,
+  pnlToday: 0,
+  pnl7d: 0,
+  pnl30d: 0,
+  totalTrades: 0,
+  tradesToday: 0,
+  winRate: 0,
+  winCount: 0,
+  lossCount: 0,
+  avgWin: 0,
+  avgLoss: 0,
+  profitFactor: 0,
+  openPositions: 0,
+  totalExposure: 0,
+  avgLeverage: 0
+};
+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";
+}
+function formatPnl(pnl) {
+  const sign = pnl >= 0 ? "+" : "";
+  if (Math.abs(pnl) >= 1e6) {
+    return `${sign}$${(pnl / 1e6).toFixed(2)}M`;
+  }
+  if (Math.abs(pnl) >= 1e3) {
+    return `${sign}$${(pnl / 1e3).toFixed(2)}K`;
+  }
+  return `${sign}$${pnl.toFixed(2)}`;
+}
+
 // src/services/engine.ts
 var OneEngineClient = class {
   constructor(options) {
@@ -2205,6 +3313,1393 @@ var styles4 = StyleSheet.create({
     color: "#888"
   }
 });
+var OneForexPoolCard = ({
+  pool,
+  poolName,
+  showMetrics = true,
+  accentColor,
+  style,
+  dark = true
+}) => {
+  const color = accentColor || pool.color;
+  const bg = dark ? "#111111" : "#ffffff";
+  const border = dark ? "#1a1a1a" : "#e5e5e5";
+  const textPrimary = dark ? "#ffffff" : "#1a1a1a";
+  const textSecondary = dark ? "#9ca3af" : "#666666";
+  const textMuted = dark ? "#666666" : "#999999";
+  const barBg = dark ? "#1a1a1a" : "#e5e5e5";
+  return /* @__PURE__ */ jsxs(View, { style: [styles5.container, { backgroundColor: bg, borderColor: border }, style], children: [
+    /* @__PURE__ */ jsxs(View, { style: styles5.header, children: [
+      /* @__PURE__ */ jsx(View, { style: [styles5.dot, { backgroundColor: color }] }),
+      /* @__PURE__ */ jsx(Text, { style: [styles5.name, { color: textPrimary }], children: poolName || pool.nameKey }),
+      /* @__PURE__ */ jsxs(Text, { style: [styles5.alloc, { color: textSecondary }], children: [
+        (pool.allocation * 100).toFixed(0),
+        "%"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(View, { style: [styles5.barOuter, { backgroundColor: barBg }], children: /* @__PURE__ */ jsx(View, { style: [styles5.barFill, { width: `${pool.utilization * 100}%`, backgroundColor: color }] }) }),
+    /* @__PURE__ */ jsxs(View, { style: styles5.statsRow, children: [
+      /* @__PURE__ */ jsxs(Text, { style: [styles5.statValue, { color: textSecondary }], children: [
+        "$",
+        (pool.totalSize / 1e6).toFixed(1),
+        "M"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { style: [styles5.statLabel, { color: textMuted }], children: [
+        (pool.utilization * 100).toFixed(1),
+        "% util"
+      ] })
+    ] }),
+    showMetrics && /* @__PURE__ */ jsxs(View, { style: [styles5.metricsRow, { borderTopColor: border }], children: [
+      /* @__PURE__ */ jsxs(View, { style: styles5.metricItem, children: [
+        /* @__PURE__ */ jsx(Text, { style: [styles5.metricLabel, { color: textMuted }], children: "APY 7d" }),
+        /* @__PURE__ */ jsxs(Text, { style: [styles5.metricValue, { color: "#10B981" }], children: [
+          pool.apy7d.toFixed(1),
+          "%"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs(View, { style: styles5.metricItem, children: [
+        /* @__PURE__ */ jsx(Text, { style: [styles5.metricLabel, { color: textMuted }], children: "24h Flow" }),
+        /* @__PURE__ */ jsxs(Text, { style: [styles5.metricValue, { color: pool.netFlow24h >= 0 ? "#10B981" : "#EF4444" }], children: [
+          pool.netFlow24h >= 0 ? "+" : "",
+          "$",
+          (pool.netFlow24h / 1e3).toFixed(0),
+          "K"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs(View, { style: styles5.metricItem, children: [
+        /* @__PURE__ */ jsx(Text, { style: [styles5.metricLabel, { color: textMuted }], children: "Txs" }),
+        /* @__PURE__ */ jsx(Text, { style: [styles5.metricValue, { color: textPrimary }], children: pool.txCount24h })
+      ] })
+    ] })
+  ] });
+};
+var styles5 = StyleSheet.create({
+  container: { borderRadius: 8, borderWidth: 1, padding: 14 },
+  header: { flexDirection: "row", alignItems: "center", marginBottom: 8, gap: 8 },
+  dot: { width: 8, height: 8, borderRadius: 4 },
+  name: { fontSize: 13, fontWeight: "600", flex: 1 },
+  alloc: { fontSize: 12 },
+  barOuter: { height: 6, borderRadius: 3, overflow: "hidden", marginBottom: 6 },
+  barFill: { height: "100%", borderRadius: 3 },
+  statsRow: { flexDirection: "row", justifyContent: "space-between" },
+  statValue: { fontSize: 12, fontWeight: "600" },
+  statLabel: { fontSize: 11 },
+  metricsRow: { flexDirection: "row", justifyContent: "space-between", paddingTop: 8, marginTop: 8, borderTopWidth: 1 },
+  metricItem: { alignItems: "center", flex: 1 },
+  metricLabel: { fontSize: 9, textTransform: "uppercase", letterSpacing: 0.5, marginBottom: 2 },
+  metricValue: { fontSize: 12, fontWeight: "600" }
+});
+
+// src/components/ai/OneForexCapitalSplit.tsx
+init_forex();
+var OneForexCapitalSplit = ({
+  amount,
+  labels = {},
+  showPoolBreakdown = true,
+  style,
+  dark = false
+}) => {
+  const allocs = computePoolAllocations(amount);
+  const bg = dark ? "#111111" : "#ffffff";
+  const border = dark ? "#1a1a1a" : "#e5e5e5";
+  const textPrimary = dark ? "#ffffff" : "#1a1a1a";
+  const textSecondary = dark ? "#9ca3af" : "#666666";
+  const itemBg = dark ? "#0a0a0a" : "#f5f5f5";
+  return /* @__PURE__ */ jsxs(View, { style: [styles6.container, { backgroundColor: bg, borderColor: border }, style], children: [
+    labels.title && /* @__PURE__ */ jsx(Text, { style: [styles6.title, { color: textPrimary }], children: labels.title }),
+    /* @__PURE__ */ jsxs(View, { style: styles6.splitRow, children: [
+      /* @__PURE__ */ jsxs(View, { style: [styles6.splitItem, { backgroundColor: itemBg }], children: [
+        /* @__PURE__ */ jsx(View, { style: [styles6.dot, { backgroundColor: "#0EA5E9" }] }),
+        /* @__PURE__ */ jsx(Text, { style: [styles6.splitLabel, { color: textSecondary }], children: labels.tradingCapital || "Active Trading (RFQ)" }),
+        /* @__PURE__ */ jsx(Text, { style: [styles6.splitPct, { color: textSecondary }], children: "50%" }),
+        /* @__PURE__ */ jsxs(Text, { style: [styles6.splitAmt, { color: textPrimary }], children: [
+          "$",
+          allocs.tradingCapital.toLocaleString()
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs(View, { style: [styles6.splitItem, { backgroundColor: itemBg }], children: [
+        /* @__PURE__ */ jsx(View, { style: [styles6.dot, { backgroundColor: "#8B5CF6" }] }),
+        /* @__PURE__ */ jsx(Text, { style: [styles6.splitLabel, { color: textSecondary }], children: labels.poolReserves || "Pool Reserves" }),
+        /* @__PURE__ */ jsx(Text, { style: [styles6.splitPct, { color: textSecondary }], children: "50%" }),
+        /* @__PURE__ */ jsxs(Text, { style: [styles6.splitAmt, { color: textPrimary }], children: [
+          "$",
+          allocs.totalPoolReserves.toLocaleString()
+        ] })
+      ] })
+    ] }),
+    showPoolBreakdown && amount > 0 && /* @__PURE__ */ jsx(View, { style: [styles6.breakdown, { borderTopColor: border }], children: FOREX_POOL_DEFAULTS.map((pool) => {
+      const poolAmt = allocs[pool.id];
+      return /* @__PURE__ */ jsxs(View, { style: styles6.poolRow, children: [
+        /* @__PURE__ */ jsx(View, { style: [styles6.poolDot, { backgroundColor: pool.color }] }),
+        /* @__PURE__ */ jsx(Text, { style: [styles6.poolName, { color: textSecondary }], children: labels?.[pool.id] || pool.nameKey }),
+        /* @__PURE__ */ jsx(View, { style: [styles6.poolBar, { backgroundColor: dark ? "#1a1a1a" : "#e5e5e5" }], children: /* @__PURE__ */ jsx(View, { style: [styles6.poolBarFill, { width: `${pool.allocation * 100}%`, backgroundColor: pool.color }] }) }),
+        /* @__PURE__ */ jsxs(Text, { style: [styles6.poolAmt, { color: textPrimary }], children: [
+          "$",
+          poolAmt.toLocaleString()
+        ] })
+      ] }, pool.id);
+    }) })
+  ] });
+};
+var styles6 = StyleSheet.create({
+  container: { borderRadius: 8, borderWidth: 1, padding: 14 },
+  title: { fontSize: 14, fontWeight: "600", marginBottom: 12 },
+  splitRow: { gap: 8 },
+  splitItem: { flexDirection: "row", alignItems: "center", paddingVertical: 10, paddingHorizontal: 12, borderRadius: 8 },
+  dot: { width: 10, height: 10, borderRadius: 5, marginRight: 8 },
+  splitLabel: { flex: 1, fontSize: 13, fontWeight: "500" },
+  splitPct: { fontSize: 12, fontWeight: "600", marginRight: 12 },
+  splitAmt: { fontSize: 14, fontWeight: "700" },
+  breakdown: { marginTop: 12, paddingTop: 12, borderTopWidth: 1 },
+  poolRow: { flexDirection: "row", alignItems: "center", marginBottom: 8 },
+  poolDot: { width: 8, height: 8, borderRadius: 4, marginRight: 8 },
+  poolName: { width: 80, fontSize: 12 },
+  poolBar: { flex: 1, height: 6, borderRadius: 3, overflow: "hidden", marginHorizontal: 8 },
+  poolBarFill: { height: "100%", borderRadius: 3 },
+  poolAmt: { width: 70, fontSize: 12, fontWeight: "600", textAlign: "right" }
+});
+var MONO = Platform.OS === "ios" ? "Courier New" : "monospace";
+var OneForexConsoleView = ({
+  logs,
+  maxItems = 100,
+  autoScroll = true,
+  style,
+  height = 400
+}) => {
+  const scrollRef = useRef(null);
+  const visibleLogs = logs.slice(-maxItems);
+  useEffect(() => {
+    if (autoScroll && scrollRef.current) {
+      setTimeout(() => scrollRef.current?.scrollToEnd({ animated: true }), 50);
+    }
+  }, [logs.length, autoScroll]);
+  const formatTime = (ts) => {
+    const d = new Date(ts);
+    return `${d.getHours().toString().padStart(2, "0")}:${d.getMinutes().toString().padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}`;
+  };
+  return /* @__PURE__ */ jsx(View, { style: [styles7.container, { height }, style], children: /* @__PURE__ */ jsxs(ScrollView, { ref: scrollRef, style: styles7.scroll, contentContainerStyle: styles7.scrollContent, children: [
+    visibleLogs.map((log) => /* @__PURE__ */ jsxs(View, { style: styles7.logRow, children: [
+      /* @__PURE__ */ jsx(Text, { style: styles7.timestamp, children: formatTime(log.timestamp) }),
+      /* @__PURE__ */ jsx(Text, { style: [styles7.type, { color: FOREX_LOG_COLORS[log.type] || "#9CA3AF" }], children: log.type.padEnd(8) }),
+      /* @__PURE__ */ jsx(Text, { style: [
+        styles7.message,
+        log.importance === "high" && styles7.messageHigh
+      ], numberOfLines: 2, children: log.message })
+    ] }, log.id)),
+    visibleLogs.length === 0 && /* @__PURE__ */ jsx(Text, { style: styles7.emptyText, children: "Waiting for trading activity..." })
+  ] }) });
+};
+var T = {
+  base: "#0A0A0C",
+  border: "#2A2A35",
+  muted: "#555560",
+  secondary: "#9CA3AF"
+};
+var styles7 = StyleSheet.create({
+  container: { backgroundColor: T.base, borderRadius: 8, borderWidth: 1, borderColor: T.border, overflow: "hidden" },
+  scroll: { flex: 1 },
+  scrollContent: { padding: 8 },
+  logRow: { flexDirection: "row", paddingVertical: 3 },
+  timestamp: { fontFamily: MONO, fontSize: 10, color: T.muted, width: 60, marginRight: 6 },
+  type: { fontFamily: MONO, fontSize: 10, fontWeight: "700", width: 65, marginRight: 6 },
+  message: { fontFamily: MONO, fontSize: 10, color: T.secondary, flex: 1 },
+  messageHigh: { color: "#ffffff", fontWeight: "600" },
+  emptyText: { fontFamily: MONO, fontSize: 11, color: T.muted, textAlign: "center", paddingVertical: 40 }
+});
+
+// src/components/ai/OneForexPairSelector.tsx
+init_forex();
+var OneForexPairSelector = ({
+  selectedPairs,
+  onTogglePair,
+  accentColor = "#0EA5E9",
+  title,
+  subtitle,
+  pairs = FOREX_CURRENCY_PAIRS,
+  style
+}) => {
+  const handleToggle = (pairId) => {
+    if (selectedPairs.includes(pairId) && selectedPairs.length <= 1) return;
+    onTogglePair(pairId);
+  };
+  return /* @__PURE__ */ jsxs(View, { style: [styles8.container, style], children: [
+    title && /* @__PURE__ */ jsx(Text, { style: styles8.title, children: title }),
+    subtitle && /* @__PURE__ */ jsx(Text, { style: styles8.subtitle, children: subtitle }),
+    /* @__PURE__ */ jsx(View, { style: styles8.pairGrid, children: pairs.map((pair) => {
+      const isSelected = selectedPairs.includes(pair.id);
+      return /* @__PURE__ */ jsxs(
+        TouchableOpacity,
+        {
+          style: [
+            styles8.pairBtn,
+            isSelected && styles8.pairBtnActive,
+            isSelected && { borderColor: accentColor, backgroundColor: accentColor + "08" }
+          ],
+          onPress: () => handleToggle(pair.id),
+          activeOpacity: 0.7,
+          children: [
+            /* @__PURE__ */ jsx(Text, { style: styles8.pairFlag, children: pair.flag }),
+            /* @__PURE__ */ jsxs(View, { style: styles8.pairInfo, children: [
+              /* @__PURE__ */ jsx(Text, { style: [styles8.pairSymbol, isSelected && { color: accentColor, fontWeight: "600" }], children: pair.symbol }),
+              /* @__PURE__ */ jsx(Text, { style: styles8.pairName, children: pair.name })
+            ] }),
+            isSelected && /* @__PURE__ */ jsx(Text, { style: [styles8.check, { color: accentColor }], children: "\u2713" })
+          ]
+        },
+        pair.id
+      );
+    }) }),
+    /* @__PURE__ */ jsxs(Text, { style: styles8.selectedInfo, children: [
+      selectedPairs.length,
+      " pair",
+      selectedPairs.length !== 1 ? "s" : "",
+      " selected (min: 1)"
+    ] })
+  ] });
+};
+var styles8 = StyleSheet.create({
+  container: { marginBottom: 16 },
+  title: { fontSize: 16, fontWeight: "600", color: "#1a1a1a", marginBottom: 4 },
+  subtitle: { fontSize: 12, color: "#666", marginBottom: 12 },
+  pairGrid: { gap: 8 },
+  pairBtn: {
+    flexDirection: "row",
+    alignItems: "center",
+    paddingHorizontal: 12,
+    paddingVertical: 12,
+    borderRadius: 8,
+    borderWidth: 1.5,
+    borderColor: "#e5e5e5",
+    backgroundColor: "#fff",
+    gap: 10
+  },
+  pairBtnActive: { borderWidth: 2 },
+  pairFlag: { fontSize: 20 },
+  pairInfo: { flex: 1 },
+  pairSymbol: { fontSize: 14, color: "#666" },
+  pairName: { fontSize: 11, color: "#999" },
+  check: { fontSize: 16, fontWeight: "700" },
+  selectedInfo: { fontSize: 12, color: "#888", marginTop: 8 }
+});
+var MONO2 = Platform.OS === "ios" ? "Courier New" : "monospace";
+var OneForexTradeHistory = ({
+  trades,
+  maxItems = 50,
+  showSettlementDetails = true,
+  showTxHash = true,
+  emptyText = "No trade history yet",
+  style
+}) => {
+  const visibleTrades = trades.slice(-maxItems).reverse();
+  if (visibleTrades.length === 0) {
+    return /* @__PURE__ */ jsx(View, { style: [styles9.empty, style], children: /* @__PURE__ */ jsx(Text, { style: styles9.emptyText, children: emptyText }) });
+  }
+  return /* @__PURE__ */ jsx(ScrollView, { style: [styles9.container, style], contentContainerStyle: styles9.scrollContent, children: visibleTrades.map((trade) => /* @__PURE__ */ jsxs(View, { style: styles9.card, children: [
+    /* @__PURE__ */ jsxs(View, { style: styles9.header, children: [
+      /* @__PURE__ */ jsx(Text, { style: styles9.pair, children: trade.pairSymbol }),
+      /* @__PURE__ */ jsx(View, { style: [
+        styles9.sideBadge,
+        { backgroundColor: trade.side === "BUY" ? "#10B98118" : "#EF444418", borderColor: trade.side === "BUY" ? "#10B98140" : "#EF444440" }
+      ], children: /* @__PURE__ */ jsx(Text, { style: [styles9.sideText, { color: trade.side === "BUY" ? "#10B981" : "#EF4444" }], children: trade.side }) }),
+      /* @__PURE__ */ jsxs(Text, { style: [styles9.pnl, { color: trade.pnl >= 0 ? "#10B981" : "#EF4444" }], children: [
+        trade.pnl >= 0 ? "+" : "",
+        "$",
+        trade.pnl.toFixed(2)
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(View, { style: styles9.details, children: [
+      /* @__PURE__ */ jsxs(Text, { style: styles9.detail, children: [
+        trade.lots.toFixed(2),
+        " lots | ",
+        trade.pips >= 0 ? "+" : "",
+        trade.pips.toFixed(1),
+        " pips"
+      ] }),
+      /* @__PURE__ */ jsx(Text, { style: styles9.time, children: new Date(trade.timestamp).toLocaleString() })
+    ] }),
+    showSettlementDetails && trade.clearingFee !== void 0 && /* @__PURE__ */ jsx(View, { style: styles9.settlement, children: /* @__PURE__ */ jsxs(Text, { style: styles9.settlementText, children: [
+      "CLR: $",
+      trade.clearingFee.toFixed(2),
+      " | HDG: $",
+      (trade.hedgingCost || 0).toFixed(2),
+      " | INS: $",
+      (trade.insuranceReserve || 0).toFixed(2)
+    ] }) }),
+    showTxHash && trade.txHash && /* @__PURE__ */ jsxs(Text, { style: styles9.txHash, children: [
+      trade.txHash.slice(0, 10),
+      "...",
+      trade.txHash.slice(-6)
+    ] })
+  ] }, trade.id)) });
+};
+var styles9 = StyleSheet.create({
+  container: { flex: 1 },
+  scrollContent: { paddingBottom: 16 },
+  empty: { alignItems: "center", justifyContent: "center", padding: 40 },
+  emptyText: { fontSize: 14, color: "#666" },
+  card: { backgroundColor: "#111111", borderRadius: 6, borderWidth: 1, borderColor: "#1a1a1a", padding: 12, marginBottom: 8 },
+  header: { flexDirection: "row", alignItems: "center", gap: 8 },
+  pair: { fontSize: 13, fontWeight: "600", color: "#ffffff" },
+  sideBadge: { paddingHorizontal: 6, paddingVertical: 2, borderRadius: 3, borderWidth: 1 },
+  sideText: { fontSize: 9, fontWeight: "700", letterSpacing: 0.5 },
+  pnl: { fontFamily: MONO2, marginLeft: "auto", fontSize: 13, fontWeight: "700" },
+  details: { flexDirection: "row", justifyContent: "space-between", marginTop: 6 },
+  detail: { fontFamily: MONO2, fontSize: 11, color: "#9ca3af" },
+  time: { fontSize: 11, color: "#666" },
+  settlement: { marginTop: 6, paddingTop: 6, borderTopWidth: 1, borderTopColor: "#1a1a1a" },
+  settlementText: { fontFamily: MONO2, fontSize: 10, color: "#666" },
+  txHash: { fontFamily: MONO2, fontSize: 9, color: "#444", marginTop: 2 }
+});
+
+// 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] = useState(FOREX_POOL_DEFAULTS);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetchPools = 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);
+    }
+  }, []);
+  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] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetchInvestments = 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 = 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 = 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;
+    }
+  }, []);
+  useEffect(() => {
+    fetchInvestments();
+    if (options?.refreshInterval) {
+      const timer = setInterval(fetchInvestments, options.refreshInterval);
+      return () => clearInterval(timer);
+    }
+  }, [fetchInvestments, options?.refreshInterval]);
+  const portfolioSummary = 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] = useState([]);
+  const [poolTxs, setPoolTxs] = useState([]);
+  const [isRunning, setIsRunning] = useState(false);
+  const [stats, setStats] = useState({ totalPnl: 0, totalTrades: 0, totalPips: 0, totalLots: 0 });
+  const engineRef = useRef(null);
+  const getEngine = useCallback(() => {
+    if (!engineRef.current) {
+      try {
+        const { forexSimulationEngine: forexSimulationEngine2 } = (init_ForexSimulationEngine(), __toCommonJS(ForexSimulationEngine_exports));
+        engineRef.current = forexSimulationEngine2;
+      } catch {
+      }
+    }
+    return engineRef.current;
+  }, []);
+  const start = useCallback(() => {
+    const engine = getEngine();
+    if (!engine) return;
+    if (!engine.isRunning()) engine.start();
+    setIsRunning(true);
+  }, [getEngine]);
+  const stop = useCallback(() => {
+    const engine = getEngine();
+    if (engine) engine.stop();
+    setIsRunning(false);
+  }, [getEngine]);
+  const clearLogs = useCallback(() => {
+    setLogs([]);
+    setPoolTxs([]);
+  }, []);
+  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] = useState({ clearing: [], hedging: [], insurance: [] });
+  const [transactions, setTransactions] = useState([]);
+  const [isInitialized, setIsInitialized] = useState(false);
+  const initialize = 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: []
+  };
+}
+
+// src/react-native.ts
+init_ForexSimulationEngine();
+init_ForexPoolDataGenerator();
+
+// src/services/forex/BotSimulationEngine.ts
+var 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
+  }
+];
+var 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
+};
+var 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" }
+};
+var 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"
+];
+var idCounter2 = 0;
+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 pick4(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 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 pick4(chains);
+  }
+  getChainLabel(chainId) {
+    const info = CHAIN_INFO[chainId];
+    return info ? info.shortName : chainId;
+  }
+  initBotState(strategy) {
+    const activePairs = this.getActivePairs(strategy);
+    const pair = pick4(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 = pick4(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}] ${pick4(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: "" };
+  }
+};
+var botSimulationEngine = new BotSimulationEngine();
 
 // src/react-native.ts
 function createCachedEngineClient(storage, options) {
@@ -2387,6 +4882,6 @@ function getExplorerUrl(chainId, hash, type = "tx") {
   return `${baseUrl}/${type}/${hash}`;
 }
 
-export { CHAIN_CONFIG, CHAIN_CONFIGS, COINGECKO_IDS, DEFAULT_SHARE_RATES, OneChainSelector, OneCycleSelector, OneEngineClient, OnePairSelector, OneSDKError, OneTierSelector, PAIR_ICONS, PriceService, TOKEN_NAMES, capitalize, checksumAddress, createCachedEngineClient, createDeepLinkHandler, createOneEngineClient, formatCryptoAmount, formatDate, formatDateTime, formatNumber, formatPercent, formatRelativeTime, formatTokenAmount, formatUSD, generateShareContent, getConfig, getExplorerUrl, initOneSDK, isOneSDKError, isValidAddress, isValidEmail, isValidPhone, omit, parseQRCode, pick, priceService, retry, shortenAddress, sleep, slugify, truncate };
+export { AGENT_STATUS_COLORS, AI_LOG_COLORS, CHAIN_CONFIG, CHAIN_CONFIGS, COINGECKO_IDS, DEFAULT_CONSOLE_METRICS, DEFAULT_CONSOLE_OPTIONS, DEFAULT_RISK_STATUS, DEFAULT_SHARE_RATES, FOREX_AGENT, FOREX_CAPITAL_SPLIT, FOREX_CURRENCY_PAIRS, FOREX_CYCLE_OPTIONS, FOREX_LOG_COLORS, FOREX_POOL_DEFAULTS, ForexPoolDataGenerator, ORDER_STATUS_CONFIG, OneChainSelector, OneCycleSelector, OneEngineClient, OneForexCapitalSplit, OneForexConsoleView, OneForexPairSelector, OneForexPoolCard, OneForexTradeHistory, OnePairSelector, OneSDKError, OneTierSelector, PAIR_ICONS, PENALTY_TIERS, PriceService, RISK_LEVELS, RISK_LEVEL_COLORS, STRATEGY_CATEGORIES, TOKEN_NAMES, TRADING_STATUS_COLORS, botSimulationEngine, calculateEarlyWithdrawalPenalty, calculateForexNetProfit, calculateRiskLevel, capitalize, checksumAddress, clearForexAccessToken, computePoolAllocations, createCachedEngineClient, createDeepLinkHandler, createOneEngineClient, estimateForexProfit, forexSimulationEngine, formatCryptoAmount, formatDate, formatDateTime, formatNumber, formatPercent, formatPnl, formatRelativeTime, formatTokenAmount, formatUSD, generateShareContent, getConfig, getExplorerUrl, initOneSDK, isOneSDKError, isValidAddress, isValidEmail, isValidPhone, omit, parseQRCode, pick, priceService, retry, setForexAccessToken, setForexEngineUrl, shortenAddress, sleep, slugify, truncate, useForexInvestments, useForexPoolData, useForexPools, useForexSimulation, useForexTrading };
 //# sourceMappingURL=react-native.mjs.map
 //# sourceMappingURL=react-native.mjs.map