@one_deploy/sdk 1.0.7 → 1.2.0

package/dist/services/index.js

@@ -2,6 +2,492 @@
 
 var supabaseJs = require('@supabase/supabase-js');
 
+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_CURRENCY_PAIRS, FOREX_POOL_DEFAULTS, FOREX_AGENT;
+var init_forex = __esm({
+  "src/types/forex.ts"() {
+    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: () => exports.ForexPoolDataGenerator
+});
+function rand(min, max) {
+  return min + Math.random() * (max - min);
+}
+function randInt(min, max) {
+  return Math.floor(rand(min, max + 1));
+}
+function pick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function genTxHash() {
+  const chars = "0123456789abcdef";
+  let hash = "0x";
+  for (let i = 0; i < 64; i++) hash += chars[Math.floor(Math.random() * 16)];
+  return hash;
+}
+function formatDate(d) {
+  return d.toISOString().split("T")[0];
+}
+function genId(prefix) {
+  return `${prefix}_${Date.now().toString(36)}_${(++_idCounter).toString(36)}`;
+}
+var _idCounter, POOL_PARAMS, ForexPoolDataGeneratorClass, _instance; exports.ForexPoolDataGenerator = void 0;
+var init_ForexPoolDataGenerator = __esm({
+  "src/services/forex/ForexPoolDataGenerator.ts"() {
+    init_forex();
+    _idCounter = 0;
+    POOL_PARAMS = {
+      clearing: {
+        meanDailyPnlPct: 35e-5,
+        stddevPnlPct: 15e-5,
+        utilizationMin: 0.7,
+        utilizationMax: 0.85,
+        depositsPerDay: [15, 25],
+        withdrawalsPerDay: [8, 12],
+        profitDistPerDay: 5,
+        avgDepositSize: 25e3,
+        avgWithdrawalSize: 18e3
+      },
+      hedging: {
+        meanDailyPnlPct: 22e-5,
+        stddevPnlPct: 2e-4,
+        utilizationMin: 0.55,
+        utilizationMax: 0.75,
+        depositsPerDay: [8, 15],
+        withdrawalsPerDay: [5, 8],
+        profitDistPerDay: 3,
+        avgDepositSize: 18e3,
+        avgWithdrawalSize: 12e3
+      },
+      insurance: {
+        meanDailyPnlPct: 13e-5,
+        stddevPnlPct: 8e-5,
+        utilizationMin: 0.3,
+        utilizationMax: 0.5,
+        depositsPerDay: [5, 10],
+        withdrawalsPerDay: [3, 5],
+        profitDistPerDay: 2,
+        avgDepositSize: 12e3,
+        avgWithdrawalSize: 8e3
+      }
+    };
+    ForexPoolDataGeneratorClass = class {
+      constructor() {
+        this.snapshotCache = null;
+        this.transactionCache = null;
+        this.baseBlockNumber = 195e5;
+      }
+      // ── Public API ─────────────────────────────────────────────────────────
+      generateAllSnapshots() {
+        if (this.snapshotCache) return this.snapshotCache;
+        const result = {
+          clearing: [],
+          hedging: [],
+          insurance: []
+        };
+        for (const pool of FOREX_POOL_DEFAULTS) {
+          result[pool.id] = this.generatePoolSnapshots(pool.id, pool.totalSize);
+        }
+        this.snapshotCache = result;
+        return result;
+      }
+      generateAllTransactions() {
+        if (this.transactionCache) return this.transactionCache;
+        const allTx = [];
+        for (const pool of FOREX_POOL_DEFAULTS) {
+          const snapshots = this.snapshotCache?.[pool.id] || this.generatePoolSnapshots(pool.id, pool.totalSize);
+          const txs = this.generatePoolTransactions(pool.id, snapshots);
+          allTx.push(...txs);
+        }
+        const now = /* @__PURE__ */ new Date();
+        for (let i = 0; i < 60; i++) {
+          const day = new Date(now);
+          day.setDate(day.getDate() - (60 - i));
+          const dayOfWeek = day.getDay();
+          if (dayOfWeek === 2 || dayOfWeek === 4 || dayOfWeek === 5 && Math.random() < 0.4) {
+            const fromPool = pick(["clearing", "hedging", "insurance"]);
+            const toOptions = ["clearing", "hedging", "insurance"].filter((p) => p !== fromPool);
+            const toPool = pick(toOptions);
+            const amount = rand(5e4, 2e5);
+            const ts = day.getTime() + randInt(10, 18) * 36e5;
+            allTx.push({
+              id: genId("ipt"),
+              poolId: fromPool,
+              type: "inter_pool_transfer",
+              amount: -amount,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + i * 7200 + randInt(0, 100),
+              timestamp: ts,
+              description: `Transfer to ${toPool} pool`
+            });
+            allTx.push({
+              id: genId("ipt"),
+              poolId: toPool,
+              type: "inter_pool_transfer",
+              amount,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + i * 7200 + randInt(100, 200),
+              timestamp: ts + 5e3,
+              description: `Transfer from ${fromPool} pool`
+            });
+          }
+          if (dayOfWeek === 3 && Math.random() < 0.85) {
+            const pool = pick(FOREX_POOL_DEFAULTS);
+            const rebalanceAmt = rand(2e4, 1e5);
+            const ts = day.getTime() + randInt(2, 6) * 36e5;
+            allTx.push({
+              id: genId("rrb"),
+              poolId: pool.id,
+              type: "reserve_rebalance",
+              amount: Math.random() < 0.5 ? rebalanceAmt : -rebalanceAmt,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + i * 7200 + randInt(200, 300),
+              timestamp: ts,
+              description: "Automated reserve rebalance"
+            });
+          }
+        }
+        allTx.sort((a, b) => a.timestamp - b.timestamp);
+        const runningBalance = {
+          clearing: FOREX_POOL_DEFAULTS[0].totalSize * 0.85,
+          hedging: FOREX_POOL_DEFAULTS[1].totalSize * 0.82,
+          insurance: FOREX_POOL_DEFAULTS[2].totalSize * 0.88
+        };
+        for (const tx of allTx) {
+          tx.balanceBefore = runningBalance[tx.poolId];
+          runningBalance[tx.poolId] += tx.amount;
+          tx.balanceAfter = runningBalance[tx.poolId];
+        }
+        this.transactionCache = allTx;
+        return allTx;
+      }
+      generateTradeHistory(investmentAmount, startDate, selectedPairs) {
+        const trades = [];
+        const start = new Date(startDate);
+        const now = /* @__PURE__ */ new Date();
+        const dayCount = Math.min(60, Math.ceil((now.getTime() - start.getTime()) / 864e5));
+        let cumulativePnl = 0;
+        let blockNum = this.baseBlockNumber + randInt(0, 5e3);
+        for (let d = 0; d < dayCount; d++) {
+          const day = new Date(start);
+          day.setDate(day.getDate() + d);
+          const dayOfWeek = day.getDay();
+          const baseCount = dayOfWeek === 0 || dayOfWeek === 6 ? randInt(1, 2) : randInt(3, 8);
+          for (let t = 0; t < baseCount; t++) {
+            const pair = FOREX_CURRENCY_PAIRS.find((p) => p.id === pick(selectedPairs)) || pick(FOREX_CURRENCY_PAIRS);
+            const side = Math.random() > 0.5 ? "BUY" : "SELL";
+            const lots = parseFloat(rand(0.1, 2.5).toFixed(2));
+            const rfqPrice = pair.basePrice * (1 + rand(-3e-3, 3e-3));
+            const quoteSpread = rand(0.5, 2) * pair.pipSize;
+            const quotePrice = side === "BUY" ? rfqPrice + quoteSpread : rfqPrice - quoteSpread;
+            const matched = Math.random() < 0.85;
+            if (!matched) continue;
+            const matchPrice = quotePrice * (1 + rand(-5e-5, 5e-5));
+            const settlePrice = matchPrice * (1 + rand(-2e-5, 2e-5));
+            const pips = (settlePrice - rfqPrice) / pair.pipSize * (side === "BUY" ? 1 : -1);
+            const pnl = pips * pair.pipSize * lots * 1e5;
+            const isWin = Math.random() < FOREX_AGENT.winRate / 100;
+            const finalPnl = isWin ? Math.abs(pnl) : -Math.abs(pnl) * rand(0.3, 0.8);
+            cumulativePnl += finalPnl;
+            const clearingFee = Math.abs(finalPnl) * rand(1e-3, 3e-3);
+            const hedgingCost = Math.abs(finalPnl) * rand(5e-4, 2e-3);
+            const insuranceReserve = Math.abs(finalPnl) * rand(3e-4, 1e-3);
+            blockNum += randInt(1, 20);
+            const timestamp = day.getTime() + randInt(0, 23) * 36e5 + randInt(0, 36e5);
+            trades.push({
+              id: genId("FXT"),
+              timestamp,
+              pairId: pair.id,
+              pairSymbol: pair.symbol,
+              side,
+              rfqPrice,
+              quotePrice,
+              matchPrice,
+              settlePrice,
+              lots,
+              pips: isWin ? Math.abs(pips) : -Math.abs(pips) * rand(0.3, 0.8),
+              pnl: finalPnl,
+              status: "SETTLED",
+              pvpSettled: true,
+              clearingFee,
+              hedgingCost,
+              insuranceReserve,
+              txHash: genTxHash(),
+              blockNumber: blockNum,
+              cycleDay: d + 1,
+              cumulativePnl
+            });
+          }
+        }
+        trades.sort((a, b) => a.timestamp - b.timestamp);
+        return trades;
+      }
+      generateLiveTransaction(poolId, type, baseAmount) {
+        const params = POOL_PARAMS[poolId];
+        let amount;
+        switch (type) {
+          case "deposit":
+            amount = baseAmount ?? rand(params.avgDepositSize * 0.5, params.avgDepositSize * 1.5);
+            break;
+          case "withdrawal":
+            amount = -(baseAmount ?? rand(params.avgWithdrawalSize * 0.5, params.avgWithdrawalSize * 1.5));
+            break;
+          case "profit_distribution":
+            amount = baseAmount ?? rand(500, 5e3);
+            break;
+          case "fee_collection":
+            amount = baseAmount ?? rand(100, 2e3);
+            break;
+          case "loss_absorption":
+            amount = -(baseAmount ?? rand(200, 3e3));
+            break;
+          default:
+            amount = baseAmount ?? rand(-5e3, 5e3);
+        }
+        const pool = FOREX_POOL_DEFAULTS.find((p) => p.id === poolId);
+        const balanceBefore = pool.totalSize;
+        return {
+          id: genId("ptx"),
+          poolId,
+          type,
+          amount,
+          balanceBefore,
+          balanceAfter: balanceBefore + amount,
+          txHash: genTxHash(),
+          blockNumber: this.baseBlockNumber + Math.floor(Date.now() / 12e3),
+          timestamp: Date.now(),
+          description: this.getTxDescription(type, poolId, Math.abs(amount))
+        };
+      }
+      // ── Private Methods ────────────────────────────────────────────────────
+      generatePoolSnapshots(poolId, currentSize) {
+        const params = POOL_PARAMS[poolId];
+        const snapshots = [];
+        const now = /* @__PURE__ */ new Date();
+        let balance = currentSize * rand(0.82, 0.88);
+        let cumulativePnl = 0;
+        for (let i = 59; i >= 0; i--) {
+          const day = new Date(now);
+          day.setDate(day.getDate() - i);
+          const dayOfWeek = day.getDay();
+          const isWeekend = dayOfWeek === 0 || dayOfWeek === 6;
+          const openBalance = balance;
+          const activityMultiplier = isWeekend ? 0.2 : 1;
+          const isDrawdown = !isWeekend && Math.random() < 0.2;
+          let dailyPnlPct;
+          if (isDrawdown) {
+            dailyPnlPct = -rand(1e-4, params.stddevPnlPct * 2);
+          } else {
+            dailyPnlPct = this.gaussianRandom(params.meanDailyPnlPct, params.stddevPnlPct);
+          }
+          dailyPnlPct *= activityMultiplier;
+          const dailyPnl = balance * dailyPnlPct;
+          cumulativePnl += dailyPnl;
+          const depositCount = isWeekend ? randInt(1, Math.ceil(params.depositsPerDay[0] * 0.2)) : randInt(params.depositsPerDay[0], params.depositsPerDay[1]);
+          const withdrawalCount = isWeekend ? randInt(0, Math.ceil(params.withdrawalsPerDay[0] * 0.2)) : randInt(params.withdrawalsPerDay[0], params.withdrawalsPerDay[1]);
+          const deposits = depositCount * params.avgDepositSize * rand(0.7, 1.3) * activityMultiplier;
+          const withdrawals = withdrawalCount * params.avgWithdrawalSize * rand(0.7, 1.3) * activityMultiplier;
+          const netFlow = deposits - withdrawals;
+          balance += dailyPnl + netFlow;
+          const txCount = depositCount + withdrawalCount + Math.round(params.profitDistPerDay * activityMultiplier);
+          const utilization = rand(params.utilizationMin, params.utilizationMax);
+          const activeUsers = Math.round(rand(80, 400) * activityMultiplier);
+          snapshots.push({
+            poolId,
+            date: formatDate(day),
+            openBalance,
+            closeBalance: balance,
+            deposits,
+            withdrawals,
+            netFlow,
+            dailyPnl,
+            dailyPnlPct,
+            cumulativePnl,
+            utilization,
+            txCount,
+            activeUsers
+          });
+        }
+        return snapshots;
+      }
+      generatePoolTransactions(poolId, snapshots) {
+        const params = POOL_PARAMS[poolId];
+        const transactions = [];
+        for (const snap of snapshots) {
+          const day = new Date(snap.date);
+          const dayOfWeek = day.getDay();
+          const isWeekend = dayOfWeek === 0 || dayOfWeek === 6;
+          const mult = isWeekend ? 0.2 : 1;
+          const depositCount = Math.round(randInt(params.depositsPerDay[0], params.depositsPerDay[1]) * mult);
+          const withdrawalCount = Math.round(randInt(params.withdrawalsPerDay[0], params.withdrawalsPerDay[1]) * mult);
+          const profitCount = Math.round(params.profitDistPerDay * mult);
+          for (let i = 0; i < depositCount; i++) {
+            const amount = rand(params.avgDepositSize * 0.3, params.avgDepositSize * 2);
+            const ts = day.getTime() + randInt(0, 23) * 36e5 + randInt(0, 36e5);
+            transactions.push({
+              id: genId("dep"),
+              poolId,
+              type: "deposit",
+              amount,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + Math.floor(ts / 12e3) + randInt(0, 50),
+              timestamp: ts,
+              description: `Deposit to ${poolId} pool`
+            });
+          }
+          for (let i = 0; i < withdrawalCount; i++) {
+            const amount = rand(params.avgWithdrawalSize * 0.3, params.avgWithdrawalSize * 2);
+            const ts = day.getTime() + randInt(0, 23) * 36e5 + randInt(0, 36e5);
+            transactions.push({
+              id: genId("wdr"),
+              poolId,
+              type: "withdrawal",
+              amount: -amount,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + Math.floor(ts / 12e3) + randInt(0, 50),
+              timestamp: ts,
+              description: `Withdrawal from ${poolId} pool`
+            });
+          }
+          for (let i = 0; i < profitCount; i++) {
+            const amount = rand(500, 8e3);
+            const ts = day.getTime() + randInt(6, 22) * 36e5 + randInt(0, 36e5);
+            transactions.push({
+              id: genId("prd"),
+              poolId,
+              type: "profit_distribution",
+              amount,
+              balanceBefore: 0,
+              balanceAfter: 0,
+              txHash: genTxHash(),
+              blockNumber: this.baseBlockNumber + Math.floor(ts / 12e3) + randInt(0, 50),
+              timestamp: ts,
+              description: `Profit distribution from ${poolId} pool`
+            });
+          }
+          if (!isWeekend) {
+            const feeCount = randInt(1, 2);
+            for (let i = 0; i < feeCount; i++) {
+              const amount = rand(100, 3e3);
+              const ts = day.getTime() + randInt(8, 20) * 36e5;
+              transactions.push({
+                id: genId("fee"),
+                poolId,
+                type: "fee_collection",
+                amount,
+                balanceBefore: 0,
+                balanceAfter: 0,
+                txHash: genTxHash(),
+                blockNumber: this.baseBlockNumber + Math.floor(ts / 12e3) + randInt(0, 50),
+                timestamp: ts,
+                description: `Fee collection for ${poolId} pool`
+              });
+            }
+          }
+        }
+        return transactions;
+      }
+      gaussianRandom(mean, stddev) {
+        let u = 0, v = 0;
+        while (u === 0) u = Math.random();
+        while (v === 0) v = Math.random();
+        const z = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+        return mean + z * stddev;
+      }
+      getTxDescription(type, poolId, amount) {
+        const fmt = `$${amount.toLocaleString(void 0, { maximumFractionDigits: 0 })}`;
+        switch (type) {
+          case "deposit":
+            return `Deposit ${fmt} to ${poolId} pool`;
+          case "withdrawal":
+            return `Withdrawal ${fmt} from ${poolId} pool`;
+          case "profit_distribution":
+            return `Profit distribution ${fmt} from ${poolId}`;
+          case "loss_absorption":
+            return `Loss absorbed ${fmt} by ${poolId} pool`;
+          case "inter_pool_transfer":
+            return `Inter-pool transfer ${fmt}`;
+          case "fee_collection":
+            return `Fee collected ${fmt} in ${poolId}`;
+          case "reserve_rebalance":
+            return `Reserve rebalance ${fmt} in ${poolId}`;
+          default:
+            return `${type} ${fmt}`;
+        }
+      }
+    };
+    _instance = null;
+    exports.ForexPoolDataGenerator = {
+      getInstance() {
+        if (!_instance) {
+          _instance = new ForexPoolDataGeneratorClass();
+        }
+        return _instance;
+      }
+    };
+  }
+});
 function getConfig() {
   {
     throw new Error("ONE SDK not initialized. Call initOneSDK() first.");
@@ -1706,13 +2192,1148 @@ function createUsageService(baseUrl) {
   return new UsageService(baseUrl);
 }
 
+// src/services/forex/ForexSimulationEngine.ts
+init_forex();
+var idCounter = 0;
+function genId2() {
+  return `fxlog_${Date.now()}_${++idCounter}`;
+}
+function tradeId() {
+  return `FXT_${Date.now().toString(36).toUpperCase()}_${(++idCounter).toString(36).toUpperCase()}`;
+}
+function rand2(min, max) {
+  return min + Math.random() * (max - min);
+}
+function randInt2(min, max) {
+  return Math.floor(rand2(min, max + 1));
+}
+function pick2(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function formatRate(price, pair) {
+  if (pair.pipSize >= 0.01) return price.toFixed(3);
+  return price.toFixed(5);
+}
+var 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"
+];
+var ForexSimulationEngine = class {
+  constructor() {
+    this.listeners = [];
+    this.poolTxListeners = [];
+    this.cycleTimer = null;
+    this.pairStates = /* @__PURE__ */ new Map();
+    this.running = false;
+    this.openPositions = [];
+    this.totalPnl = 0;
+    this.totalTrades = 0;
+    this.totalPips = 0;
+    this.totalLots = 0;
+    for (const pair of FOREX_CURRENCY_PAIRS) {
+      const jitter = pair.basePrice * rand2(-3e-3, 3e-3);
+      const price = pair.basePrice + jitter;
+      const halfSpread = pair.spreadPips * pair.pipSize / 2;
+      this.pairStates.set(pair.id, {
+        pair,
+        currentPrice: price,
+        bidPrice: price - halfSpread,
+        askPrice: price + halfSpread,
+        lastSpread: pair.spreadPips
+      });
+    }
+  }
+  // ── Public API ─────────────────────────────────────────────────────────────
+  start() {
+    this.running = true;
+    this.scheduleCycle();
+  }
+  stop() {
+    this.running = false;
+    if (this.cycleTimer) {
+      clearTimeout(this.cycleTimer);
+      this.cycleTimer = null;
+    }
+  }
+  onLog(callback) {
+    this.listeners.push(callback);
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== callback);
+    };
+  }
+  onPoolTransaction(callback) {
+    this.poolTxListeners.push(callback);
+    return () => {
+      this.poolTxListeners = this.poolTxListeners.filter((l) => l !== callback);
+    };
+  }
+  isRunning() {
+    return this.running;
+  }
+  getStats() {
+    return {
+      totalPnl: this.totalPnl,
+      totalTrades: this.totalTrades,
+      totalPips: this.totalPips,
+      totalLots: this.totalLots,
+      positions: this.openPositions.length
+    };
+  }
+  getPairStates() {
+    return this.pairStates;
+  }
+  emitBootSequence() {
+    const bootMessages = [
+      { msg: "Initializing StableFX Engine v2.1.0...", delay: 0 },
+      { msg: "Connecting to Circle StableFX RFQ network...", delay: 500 },
+      { msg: "Loading USDC stablecoin pair feeds (6 pairs)...", delay: 1200 },
+      { msg: "Calibrating PvP settlement engine...", delay: 2e3 },
+      { msg: "Initializing clearing pool ($12.5M)...", delay: 2800 },
+      { msg: "Initializing hedging pool ($7.5M)...", delay: 3400 },
+      { msg: "Initializing insurance pool ($5.0M)...", delay: 4e3 },
+      { msg: "Risk management module online (max exposure: 25%)", delay: 4500 },
+      { msg: "=== StableFX Engine ready. Starting RFQ cycles ===", delay: 5e3 }
+    ];
+    for (const { msg, delay } of bootMessages) {
+      setTimeout(() => {
+        this.emit({
+          id: genId2(),
+          timestamp: Date.now(),
+          type: "SYSTEM",
+          message: msg,
+          importance: "medium"
+        });
+      }, delay);
+    }
+  }
+  destroy() {
+    this.stop();
+    this.listeners = [];
+    this.poolTxListeners = [];
+    this.pairStates.clear();
+    this.openPositions = [];
+  }
+  // ── Private Methods ────────────────────────────────────────────────────────
+  emit(entry) {
+    for (const listener of this.listeners) {
+      listener(entry);
+    }
+  }
+  emitPoolTx(tx) {
+    for (const listener of this.poolTxListeners) {
+      listener(tx);
+    }
+  }
+  generatePoolTxFromEvent(type, data) {
+    try {
+      const { ForexPoolDataGenerator: ForexPoolDataGenerator2 } = (init_ForexPoolDataGenerator(), __toCommonJS(ForexPoolDataGenerator_exports));
+      const generator = ForexPoolDataGenerator2.getInstance();
+      if (type === "SETTLE" && data.pnl !== void 0) {
+        const tx = generator.generateLiveTransaction("clearing", "fee_collection", Math.abs(data.pnl) * rand2(1e-3, 3e-3));
+        this.emitPoolTx(tx);
+      } else if (type === "HEDGE") {
+        const tx = generator.generateLiveTransaction("hedging", data.pnl && data.pnl < 0 ? "loss_absorption" : "profit_distribution", Math.abs(data.lots || 1) * rand2(50, 200));
+        this.emitPoolTx(tx);
+      } else if (type === "CLEAR") {
+        const tx = generator.generateLiveTransaction("clearing", "profit_distribution", (data.volume || 1e5) * rand2(1e-4, 5e-4));
+        this.emitPoolTx(tx);
+      }
+    } catch {
+    }
+  }
+  scheduleCycle() {
+    if (!this.running) return;
+    const interval = rand2(8e3, 14e3);
+    this.cycleTimer = setTimeout(() => {
+      if (this.running) {
+        this.runTradeCycle();
+        this.scheduleCycle();
+      }
+    }, interval);
+  }
+  simulatePrice(pairId) {
+    const state = this.pairStates.get(pairId);
+    if (!state) return 0;
+    const volatility = state.pair.id.includes("JPYC") ? 8e-4 : 4e-4;
+    const drift = rand2(-volatility, volatility);
+    const newPrice = state.currentPrice * (1 + drift);
+    const halfSpread = (state.pair.spreadPips + rand2(-0.3, 0.3)) * state.pair.pipSize / 2;
+    state.currentPrice = newPrice;
+    state.bidPrice = newPrice - halfSpread;
+    state.askPrice = newPrice + halfSpread;
+    state.lastSpread = halfSpread * 2 / state.pair.pipSize;
+    return newPrice;
+  }
+  runTradeCycle() {
+    const pairState = pick2(Array.from(this.pairStates.values()));
+    const pair = pairState.pair;
+    const entries = [];
+    let delay = 0;
+    const price = this.simulatePrice(pair.id);
+    const side = Math.random() > 0.5 ? "BUY" : "SELL";
+    const lots = parseFloat(rand2(0.1, 2.5).toFixed(2));
+    const notional = lots * 1e5;
+    const rfqId = tradeId();
+    entries.push({
+      entry: {
+        type: "RFQ",
+        message: `RFQ ${rfqId} | ${pair.symbol} ${side} ${lots.toFixed(2)} lots ($${(notional / 1e3).toFixed(0)}K) | Mid: ${formatRate(price, pair)}`,
+        data: { rfqId, pair: pair.id, side, lots, price },
+        importance: "medium",
+        pairId: pair.id
+      },
+      delay
+    });
+    delay += rand2(400, 800);
+    const quoteSpread = rand2(0.5, 2) * pair.pipSize;
+    const quotePrice = side === "BUY" ? price + quoteSpread : price - quoteSpread;
+    const quotePips = Math.abs(quotePrice - price) / pair.pipSize;
+    entries.push({
+      entry: {
+        type: "QUOTE",
+        message: `QUOTE ${rfqId} | ${pair.symbol} @ ${formatRate(quotePrice, pair)} | Spread: ${quotePips.toFixed(1)} pips | Valid: 3s`,
+        data: { rfqId, quotePrice, spread: quotePips },
+        importance: "medium",
+        pairId: pair.id
+      },
+      delay
+    });
+    delay += rand2(500, 1e3);
+    const matched = Math.random() < 0.85;
+    if (matched) {
+      const matchPrice = quotePrice * (1 + rand2(-5e-5, 5e-5));
+      entries.push({
+        entry: {
+          type: "MATCH",
+          message: `MATCH ${rfqId} | ${pair.symbol} ${side} @ ${formatRate(matchPrice, pair)} | ${lots.toFixed(2)} lots | Counterparty: LP-${randInt2(1, 8)}`,
+          data: { rfqId, matchPrice, counterparty: `LP-${randInt2(1, 8)}` },
+          importance: "high",
+          pairId: pair.id
+        },
+        delay
+      });
+      delay += rand2(1e3, 2500);
+      const settlePrice = matchPrice * (1 + rand2(-2e-5, 2e-5));
+      const pips = (settlePrice - price) / pair.pipSize * (side === "BUY" ? 1 : -1);
+      const pnl = pips * pair.pipSize * lots * 1e5;
+      entries.push({
+        entry: {
+          type: "SETTLE",
+          message: `SETTLE ${rfqId} | PvP confirmed | ${pair.symbol} @ ${formatRate(settlePrice, pair)} | P&L: ${pips >= 0 ? "+" : ""}${pips.toFixed(1)} pips ($${pnl >= 0 ? "+" : ""}${pnl.toFixed(2)})`,
+          data: { rfqId, settlePrice, pips, pnl, pvp: true },
+          importance: "high",
+          pairId: pair.id
+        },
+        delay
+      });
+      delay += rand2(300, 600);
+      entries.push({
+        entry: {
+          type: "PVP",
+          message: `PvP ${rfqId} | Atomic settlement confirmed on-chain | USDC transferred: $${notional.toLocaleString()} | Gas: ~$0.${randInt2(10, 50)}`,
+          data: { rfqId, settled: true, gasWei: randInt2(10, 50) },
+          importance: "medium",
+          pairId: pair.id
+        },
+        delay
+      });
+      this.generatePoolTxFromEvent("SETTLE", { pnl });
+      this.totalTrades++;
+      this.totalPnl += pnl;
+      this.totalPips += pips;
+      this.totalLots += lots;
+      if (Math.random() < 0.4) {
+        this.openPositions.push({
+          id: rfqId,
+          pairId: pair.id,
+          side,
+          lots,
+          pips,
+          entryPrice: matchPrice,
+          currentPrice: settlePrice,
+          pnl,
+          openTime: Date.now()
+        });
+        if (this.openPositions.length > 5) {
+          this.openPositions.shift();
+        }
+      }
+    } else {
+      entries.push({
+        entry: {
+          type: "MATCH",
+          message: `MATCH FAILED ${rfqId} | ${pair.symbol} | No counterparty at requested price | Requoting...`,
+          data: { rfqId, matched: false },
+          importance: "low",
+          pairId: pair.id
+        },
+        delay
+      });
+    }
+    if (Math.random() < 0.2) {
+      delay += rand2(400, 800);
+      const hedgePair = pick2(FOREX_CURRENCY_PAIRS);
+      const hedgeLots = parseFloat(rand2(0.5, 5).toFixed(2));
+      const hedgeDirection = Math.random() > 0.5 ? "LONG" : "SHORT";
+      entries.push({
+        entry: {
+          type: "HEDGE",
+          message: `HEDGE | ${hedgePair.symbol} ${hedgeDirection} ${hedgeLots.toFixed(2)} lots | Pool delta neutralization | Exposure: ${rand2(5, 20).toFixed(1)}%`,
+          data: { pair: hedgePair.id, direction: hedgeDirection, lots: hedgeLots },
+          importance: "medium"
+        },
+        delay
+      });
+      this.generatePoolTxFromEvent("HEDGE", { lots: hedgeLots });
+    }
+    if (Math.random() < 0.15) {
+      delay += rand2(300, 600);
+      const clearAmount = randInt2(5e4, 5e5);
+      entries.push({
+        entry: {
+          type: "CLEAR",
+          message: `CLEAR | Netting cycle complete | Volume: $${(clearAmount / 1e3).toFixed(0)}K | Pairs settled: ${randInt2(2, 6)} | Pool util: ${rand2(60, 85).toFixed(1)}%`,
+          data: { volume: clearAmount, pairsSettled: randInt2(2, 6) },
+          importance: "low"
+        },
+        delay
+      });
+      this.generatePoolTxFromEvent("CLEAR", { volume: clearAmount });
+    }
+    if (this.openPositions.length > 0 && Math.random() < 0.25) {
+      delay += rand2(300, 600);
+      const posUpdates = this.openPositions.slice(0, 3).map((pos) => {
+        const pState = this.pairStates.get(pos.pairId);
+        if (pState) {
+          pos.currentPrice = pState.currentPrice;
+          pos.pips = (pos.currentPrice - pos.entryPrice) / pState.pair.pipSize * (pos.side === "BUY" ? 1 : -1);
+          pos.pnl = pos.pips * pState.pair.pipSize * pos.lots * 1e5;
+        }
+        return `${pState?.pair.symbol || pos.pairId} ${pos.side}: ${pos.pips >= 0 ? "+" : ""}${pos.pips.toFixed(1)} pips`;
+      });
+      entries.push({
+        entry: {
+          type: "POSITION",
+          message: `POSITION | ${posUpdates.join(" | ")} | Open: ${this.openPositions.length}`,
+          data: { positions: this.openPositions.length },
+          importance: "low"
+        },
+        delay
+      });
+      if (this.openPositions.length > 2 && Math.random() < 0.3) {
+        const closed = this.openPositions.shift();
+        this.totalPnl += closed.pnl * rand2(0.01, 0.03);
+      }
+    }
+    if (Math.random() < 0.3) {
+      delay += rand2(300, 600);
+      entries.push({
+        entry: {
+          type: "PNL",
+          message: `PNL | Session: $${this.totalPnl >= 0 ? "+" : ""}${this.totalPnl.toFixed(2)} | Trades: ${this.totalTrades} | Pips: ${this.totalPips >= 0 ? "+" : ""}${this.totalPips.toFixed(1)} | Lots: ${this.totalLots.toFixed(2)}`,
+          data: { totalPnl: this.totalPnl, totalTrades: this.totalTrades, totalPips: this.totalPips },
+          importance: "medium"
+        },
+        delay
+      });
+    }
+    if (Math.random() < 0.1) {
+      delay += rand2(300, 600);
+      entries.push({
+        entry: {
+          type: "SYSTEM",
+          message: `[Market] ${pick2(FX_NEWS)}`,
+          importance: "medium"
+        },
+        delay
+      });
+    }
+    for (const { entry, delay: d } of entries) {
+      setTimeout(() => {
+        if (this.running) {
+          this.emit({
+            ...entry,
+            id: genId2(),
+            timestamp: Date.now()
+          });
+        }
+      }, d);
+    }
+  }
+};
+var forexSimulationEngine = new ForexSimulationEngine();
+
+// src/services/forex/index.ts
+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 pick3(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function clamp(val, min, max) {
+  return Math.max(min, Math.min(max, val));
+}
+function formatPrice(price) {
+  if (price >= 1e3) return price.toFixed(2);
+  if (price >= 1) return price.toFixed(3);
+  return price.toFixed(5);
+}
+var BotSimulationEngine = class {
+  constructor() {
+    this.listeners = [];
+    this.botTimers = /* @__PURE__ */ new Map();
+    this.botStates = /* @__PURE__ */ new Map();
+    this.priceState = /* @__PURE__ */ new Map();
+    this.indicatorState = /* @__PURE__ */ new Map();
+    this.running = false;
+    this.userPairs = [];
+    this.userChains = [];
+    for (const [pair, base] of Object.entries(PAIR_PRICES)) {
+      this.priceState.set(pair, base * (1 + rand3(-0.02, 0.02)));
+    }
+  }
+  // ── Public API ─────────────────────────────────────────────────────────────
+  getStrategies() {
+    return STRATEGY_PERSONALITIES;
+  }
+  start(strategyIds, userPairs, userChains) {
+    this.running = true;
+    this.userPairs = (userPairs || []).map((p) => p.includes("/") ? p : `${p}/USDT`).filter((p) => p in PAIR_PRICES);
+    this.userChains = (userChains || []).filter((c) => c in CHAIN_INFO);
+    const strategies = strategyIds ? STRATEGY_PERSONALITIES.filter((s) => strategyIds.includes(s.id)) : STRATEGY_PERSONALITIES;
+    for (const strategy of strategies) {
+      this.initBotState(strategy);
+      this.scheduleCycle(strategy);
+    }
+  }
+  stop(strategyIds) {
+    const ids = strategyIds || Array.from(this.botTimers.keys());
+    for (const id of ids) {
+      const timer = this.botTimers.get(id);
+      if (timer) {
+        clearTimeout(timer);
+        this.botTimers.delete(id);
+      }
+    }
+    if (!strategyIds) {
+      this.running = false;
+    }
+  }
+  onLog(callback) {
+    this.listeners.push(callback);
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== callback);
+    };
+  }
+  getBotState(strategyId) {
+    return this.botStates.get(strategyId);
+  }
+  getAllBotStates() {
+    return this.botStates;
+  }
+  isRunning() {
+    return this.running;
+  }
+  emitBootSequence() {
+    const bootMessages = [
+      { msg: "Initializing ONE Trading Engine v3.2.1...", delay: 0 },
+      { msg: "Loading market data feeds...", delay: 500 },
+      { msg: "Connecting to exchange WebSocket streams...", delay: 1200 },
+      { msg: "Calibrating indicator engines (RSI, MACD, EMA, Bollinger)...", delay: 2e3 },
+      { msg: "Loading strategy personalities: balanced-01, conservative-01, aggressive-01", delay: 2800 },
+      { msg: "Risk management module initialized (max drawdown: 15%)", delay: 3600 },
+      { msg: "Portfolio allocation engine ready", delay: 4200 },
+      { msg: "=== All systems online. Starting trading cycles ===", delay: 5e3 }
+    ];
+    for (const { msg, delay } of bootMessages) {
+      setTimeout(() => {
+        this.emit({
+          id: genId3(),
+          timestamp: Date.now(),
+          strategyId: "system",
+          strategyName: "SYSTEM",
+          type: "SYSTEM",
+          message: msg,
+          importance: "medium"
+        });
+      }, delay);
+    }
+  }
+  destroy() {
+    this.stop();
+    this.listeners = [];
+    this.botStates.clear();
+    this.priceState.clear();
+    this.indicatorState.clear();
+    this.userPairs = [];
+    this.userChains = [];
+  }
+  // ── Private Methods ────────────────────────────────────────────────────────
+  emit(entry) {
+    for (const listener of this.listeners) {
+      listener(entry);
+    }
+  }
+  getActivePairs(strategy) {
+    return this.userPairs.length > 0 ? this.userPairs : strategy.preferredPairs;
+  }
+  getActiveChain() {
+    const chains = this.userChains.length > 0 ? this.userChains : ["ethereum", "arbitrum", "bsc"];
+    return pick3(chains);
+  }
+  getChainLabel(chainId) {
+    const info = CHAIN_INFO[chainId];
+    return info ? info.shortName : chainId;
+  }
+  initBotState(strategy) {
+    const activePairs = this.getActivePairs(strategy);
+    const pair = pick3(activePairs);
+    const price = this.priceState.get(pair) || PAIR_PRICES[pair] || 5e4;
+    const indicators = this.generateIndicators(strategy, price);
+    this.indicatorState.set(strategy.id, indicators);
+    this.botStates.set(strategy.id, {
+      strategyId: strategy.id,
+      strategyName: strategy.name,
+      isRunning: true,
+      currentPair: pair,
+      currentPrice: price,
+      indicators,
+      openPositions: [],
+      totalPnl: rand3(-50, 200),
+      totalTrades: randInt3(5, 25),
+      winRate: rand3(0.48, 0.68),
+      lastSignal: "HOLD",
+      lastSignalConfidence: 0
+    });
+  }
+  scheduleCycle(strategy) {
+    if (!this.running) return;
+    const interval = rand3(strategy.scanIntervalMin, strategy.scanIntervalMax);
+    const timer = setTimeout(() => {
+      if (this.running) {
+        this.runBotCycle(strategy);
+        this.scheduleCycle(strategy);
+      }
+    }, interval);
+    this.botTimers.set(strategy.id, timer);
+  }
+  async runBotCycle(strategy) {
+    const state = this.botStates.get(strategy.id);
+    if (!state) return;
+    const activePairs = this.getActivePairs(strategy);
+    const pair = pick3(activePairs);
+    const price = this.simulatePrice(pair);
+    const indicators = this.generateIndicators(strategy, price);
+    this.indicatorState.set(strategy.id, indicators);
+    state.currentPair = pair;
+    state.currentPrice = price;
+    state.indicators = indicators;
+    const entries = [];
+    let delay = 0;
+    const chain = this.getActiveChain();
+    const chainLabel = this.getChainLabel(chain);
+    entries.push({
+      entry: {
+        strategyId: strategy.id,
+        strategyName: strategy.shortName,
+        type: "SCAN",
+        message: `Scanning ${pair} on ${chainLabel} | Price: $${formatPrice(price)}`,
+        data: { pair, chain, chainLabel },
+        importance: "low"
+      },
+      delay
+    });
+    delay += rand3(800, 1500);
+    const thinkingMessages = this.generateThinkingProcess(strategy, pair, price);
+    for (const thinking of thinkingMessages) {
+      entries.push({
+        entry: {
+          strategyId: strategy.id,
+          strategyName: strategy.shortName,
+          type: "THINKING",
+          message: thinking,
+          importance: "low"
+        },
+        delay
+      });
+      delay += rand3(600, 1200);
+    }
+    const indicatorParts = [];
+    if (strategy.primaryIndicators.includes("RSI") || strategy.primaryIndicators.includes("MACD")) {
+      indicatorParts.push(`RSI: ${indicators.rsi.toFixed(1)}`);
+    }
+    if (strategy.primaryIndicators.includes("MACD") || strategy.primaryIndicators.includes("RSI")) {
+      indicatorParts.push(`MACD: ${indicators.macd.histogram > 0 ? "+" : ""}${indicators.macd.histogram.toFixed(3)}`);
+    }
+    if (strategy.primaryIndicators.includes("EMA")) {
+      indicatorParts.push(`EMA: ${indicators.ema.short.toFixed(1)}/${indicators.ema.long.toFixed(1)}`);
+      if (indicators.ema.crossover !== "none") {
+        indicatorParts.push(`[${indicators.ema.crossover.toUpperCase()} CROSS]`);
+      }
+    }
+    if (strategy.primaryIndicators.includes("Bollinger")) {
+      indicatorParts.push(`BB: ${indicators.bollinger.position.toFixed(1)}% width=${indicators.bollinger.width.toFixed(2)}`);
+    }
+    if (strategy.primaryIndicators.includes("Volume")) {
+      indicatorParts.push(`Vol: ${indicators.volume.ratio.toFixed(2)}x avg`);
+    }
+    entries.push({
+      entry: {
+        strategyId: strategy.id,
+        strategyName: strategy.shortName,
+        type: "INDICATOR",
+        message: indicatorParts.join(" | "),
+        data: { indicators },
+        importance: "low"
+      },
+      delay
+    });
+    delay += rand3(800, 1500);
+    if (Math.random() < 0.12) {
+      const sentiment = Math.random() > 0.4 ? "Bullish" : "Bearish";
+      entries.push({
+        entry: {
+          strategyId: strategy.id,
+          strategyName: strategy.shortName,
+          type: "NEWS",
+          message: `[${sentiment}] ${pick3(NEWS_HEADLINES)}`,
+          importance: "medium"
+        },
+        delay
+      });
+      delay += rand3(1e3, 1800);
+    }
+    if (Math.random() < 0.4) {
+      const analysis = this.generateAnalysis(strategy, indicators, pair);
+      entries.push({
+        entry: {
+          strategyId: strategy.id,
+          strategyName: strategy.shortName,
+          type: "ANALYSIS",
+          message: analysis,
+          importance: "medium"
+        },
+        delay
+      });
+      delay += rand3(1e3, 2e3);
+    }
+    const signal = this.evaluateSignal(strategy, indicators);
+    state.lastSignal = signal.direction;
+    state.lastSignalConfidence = signal.confidence;
+    if (signal.direction !== "HOLD") {
+      const strategyContext = this.generateStrategyContext(strategy, signal, indicators, pair);
+      entries.push({
+        entry: {
+          strategyId: strategy.id,
+          strategyName: strategy.shortName,
+          type: "STRATEGY",
+          message: strategyContext,
+          data: {
+            strategy: strategy.name,
+            riskTolerance: strategy.riskTolerance,
+            primaryIndicators: strategy.primaryIndicators,
+            signal: signal.direction,
+            confidence: signal.confidence
+          },
+          importance: "high"
+        },
+        delay
+      });
+      delay += rand3(1500, 2500);
+      entries.push({
+        entry: {
+          strategyId: strategy.id,
+          strategyName: strategy.shortName,
+          type: "SIGNAL",
+          message: `${signal.direction} signal detected | Confidence: ${(signal.confidence * 100).toFixed(1)}% | ${signal.reason}`,
+          data: { signal },
+          importance: "high"
+        },
+        delay
+      });
+      delay += rand3(1200, 2e3);
+      const decision = this.makeTradeDecision(strategy, signal, state);
+      if (decision.execute) {
+        entries.push({
+          entry: {
+            strategyId: strategy.id,
+            strategyName: strategy.shortName,
+            type: "DECISION",
+            message: `Execute ${signal.direction} | Size: ${decision.positionSize.toFixed(1)}% | Leverage: ${decision.leverage}x | Risk/Reward: 1:${decision.riskReward.toFixed(1)}`,
+            data: {
+              strategyName: strategy.name,
+              strategyId: strategy.id,
+              riskTolerance: strategy.riskTolerance,
+              signalReason: signal.reason,
+              confidence: signal.confidence
+            },
+            importance: "high"
+          },
+          delay
+        });
+        delay += rand3(1e3, 1800);
+        const orderId = `ORD_${Date.now().toString(36).toUpperCase()}`;
+        const orderPrice = signal.direction === "LONG" ? price * (1 - rand3(1e-4, 5e-4)) : price * (1 + rand3(1e-4, 5e-4));
+        entries.push({
+          entry: {
+            strategyId: strategy.id,
+            strategyName: strategy.shortName,
+            type: "ORDER",
+            message: `Submitting ${signal.direction} order | ${pair} @ $${formatPrice(orderPrice)} on ${chainLabel} | ID: ${orderId}`,
+            data: {
+              orderId,
+              pair,
+              side: signal.direction,
+              price: orderPrice,
+              leverage: decision.leverage,
+              chain,
+              chainLabel,
+              strategyName: strategy.name,
+              strategyContext,
+              signalReason: signal.reason
+            },
+            importance: "high"
+          },
+          delay
+        });
+        delay += rand3(2e3, 4e3);
+        const fillPrice = orderPrice * (1 + rand3(-3e-4, 3e-4));
+        const slippage = Math.abs(fillPrice - orderPrice) / orderPrice * 100;
+        entries.push({
+          entry: {
+            strategyId: strategy.id,
+            strategyName: strategy.shortName,
+            type: "FILLED",
+            message: `Order FILLED | ${pair} ${signal.direction} @ $${formatPrice(fillPrice)} on ${chainLabel} | Slippage: ${slippage.toFixed(4)}% | ID: ${orderId}`,
+            data: {
+              orderId,
+              fillPrice,
+              slippage,
+              chain,
+              chainLabel,
+              strategyName: strategy.name,
+              executedBy: strategy.id
+            },
+            importance: "high"
+          },
+          delay
+        });
+        const position = {
+          id: orderId,
+          pair,
+          side: signal.direction,
+          entryPrice: fillPrice,
+          currentPrice: price,
+          size: decision.positionSize,
+          leverage: decision.leverage,
+          pnl: 0,
+          pnlPercent: 0
+        };
+        state.openPositions = [...state.openPositions.slice(-2), position];
+        state.totalTrades++;
+      } else {
+        entries.push({
+          entry: {
+            strategyId: strategy.id,
+            strategyName: strategy.shortName,
+            type: "DECISION",
+            message: `SKIP - ${decision.reason}`,
+            importance: "medium"
+          },
+          delay
+        });
+      }
+    }
+    if (state.openPositions.length > 0 && Math.random() < 0.5) {
+      delay += rand3(1500, 2500);
+      let totalPositionPnl = 0;
+      const pnlParts = [];
+      for (const pos of state.openPositions) {
+        pos.currentPrice = this.simulatePrice(pos.pair);
+        const priceDiff = pos.side === "LONG" ? (pos.currentPrice - pos.entryPrice) / pos.entryPrice : (pos.entryPrice - pos.currentPrice) / pos.entryPrice;
+        pos.pnlPercent = priceDiff * pos.leverage * 100;
+        pos.pnl = priceDiff * pos.leverage * pos.size;
+        totalPositionPnl += pos.pnl;
+        pnlParts.push(`${pos.pair} ${pos.side}: ${pos.pnlPercent >= 0 ? "+" : ""}${pos.pnlPercent.toFixed(2)}%`);
+      }
+      state.totalPnl += totalPositionPnl * rand3(0.01, 0.05);
+      if (state.openPositions.length > 1 && Math.random() < 0.3) {
+        const closed = state.openPositions.shift();
+        const finalPnl = closed.pnlPercent;
+        if (finalPnl > 0) {
+          state.winRate = state.winRate * 0.95 + 0.05;
+        } else {
+          state.winRate = state.winRate * 0.95;
+        }
+        state.winRate = clamp(state.winRate, 0.35, 0.75);
+        pnlParts.push(`CLOSED ${closed.pair}: ${finalPnl >= 0 ? "+" : ""}${finalPnl.toFixed(2)}%`);
+      }
+      entries.push({
+        entry: {
+          strategyId: strategy.id,
+          strategyName: strategy.shortName,
+          type: "PNL",
+          message: pnlParts.join(" | "),
+          data: { totalPnl: state.totalPnl, positions: state.openPositions.length },
+          importance: "medium"
+        },
+        delay
+      });
+    }
+    if (Math.random() < 0.2) {
+      delay += rand3(1e3, 2e3);
+      const exposure = state.openPositions.reduce((sum, p) => sum + p.size * p.leverage, 0);
+      const maxDrawdown = rand3(2, 12);
+      entries.push({
+        entry: {
+          strategyId: strategy.id,
+          strategyName: strategy.shortName,
+          type: "RISK",
+          message: `Portfolio exposure: ${exposure.toFixed(1)}% | Max drawdown: ${maxDrawdown.toFixed(1)}% | Open positions: ${state.openPositions.length} | Win rate: ${(state.winRate * 100).toFixed(1)}%`,
+          importance: exposure > 80 ? "high" : "low"
+        },
+        delay
+      });
+    }
+    for (const { entry, delay: d } of entries) {
+      setTimeout(() => {
+        if (this.running) {
+          this.emit({
+            ...entry,
+            id: genId3(),
+            timestamp: Date.now()
+          });
+        }
+      }, d);
+    }
+  }
+  simulatePrice(pair) {
+    const current = this.priceState.get(pair) || PAIR_PRICES[pair] || 5e4;
+    const volatility = pair.includes("DOGE") ? 5e-3 : pair.includes("BTC") ? 2e-3 : 3e-3;
+    const drift = rand3(-volatility, volatility);
+    const newPrice = current * (1 + drift);
+    this.priceState.set(pair, newPrice);
+    return newPrice;
+  }
+  generateIndicators(strategy, price) {
+    const prev = this.indicatorState.get(strategy.id);
+    const prevRsi = prev?.rsi ?? strategy.rsiBias;
+    const rsiMean = strategy.rsiBias;
+    const rsiDrift = rand3(-8, 8);
+    const rsiReversion = (rsiMean - prevRsi) * 0.15;
+    const rsi = clamp(prevRsi + rsiDrift + rsiReversion, 8, 95);
+    const macdBias = rsi > 65 ? 0.3 : rsi < 35 ? -0.3 : 0;
+    const prevHist = prev?.macd.histogram ?? 0;
+    const histogram = clamp(prevHist * 0.7 + rand3(-0.5, 0.5) + macdBias, -2, 2);
+    const macdValue = histogram * rand3(0.8, 1.5);
+    const macdSignal = macdValue - histogram;
+    const prevShort = prev?.ema.short ?? price;
+    const prevLong = prev?.ema.long ?? price;
+    const emaShort = prevShort * 0.9 + price * 0.1;
+    const emaLong = prevLong * 0.95 + price * 0.05;
+    let crossover = "none";
+    if (prevShort <= prevLong && emaShort > emaLong) crossover = "golden";
+    else if (prevShort >= prevLong && emaShort < emaLong) crossover = "death";
+    const bbMiddle = price;
+    const bbWidth = price * rand3(0.01, 0.04);
+    const bbUpper = bbMiddle + bbWidth;
+    const bbLower = bbMiddle - bbWidth;
+    const bbPosition = (price - bbLower) / (bbUpper - bbLower) * 100;
+    const volRatio = rand3(0.3, 2.5);
+    const volCurrent = rand3(1e5, 5e6);
+    return {
+      rsi,
+      macd: { value: macdValue, signal: macdSignal, histogram },
+      ema: { short: emaShort, long: emaLong, crossover },
+      bollinger: { upper: bbUpper, middle: bbMiddle, lower: bbLower, width: bbWidth / price, position: bbPosition },
+      volume: { current: volCurrent, average: volCurrent / volRatio, ratio: volRatio }
+    };
+  }
+  generateThinkingProcess(strategy, pair, price) {
+    const thoughts = [];
+    const pairBase = pair.split("/")[0];
+    const thinkingTemplates = [
+      `Analyzing ${pairBase} market structure...`,
+      `Checking ${strategy.primaryIndicators.join(", ")} confluence...`,
+      `Evaluating risk parameters for ${strategy.riskTolerance} tolerance...`,
+      `Scanning order book depth at $${formatPrice(price)}...`,
+      `Cross-referencing with historical patterns...`,
+      `Calculating optimal entry zone...`,
+      `Assessing market sentiment indicators...`,
+      `Monitoring whale activity on ${pairBase}...`,
+      `Comparing momentum across timeframes...`,
+      `Validating support/resistance levels...`
+    ];
+    const numThoughts = randInt3(1, 3);
+    const shuffled = [...thinkingTemplates].sort(() => Math.random() - 0.5);
+    for (let i = 0; i < numThoughts; i++) {
+      thoughts.push(shuffled[i]);
+    }
+    return thoughts;
+  }
+  generateStrategyContext(strategy, signal, indicators, pair) {
+    const contexts = [];
+    contexts.push(`[${strategy.name}]`);
+    const riskLevel = strategy.riskTolerance === "high" ? "aggressive" : strategy.riskTolerance === "low" ? "conservative" : "balanced";
+    contexts.push(`Risk: ${riskLevel}`);
+    if (indicators.rsi < 35 || indicators.rsi > 65) {
+      contexts.push(`RSI ${indicators.rsi < 35 ? "oversold" : "overbought"} (${indicators.rsi.toFixed(1)})`);
+    }
+    if (indicators.ema.crossover !== "none") {
+      contexts.push(`EMA ${indicators.ema.crossover} cross`);
+    }
+    if (Math.abs(indicators.macd.histogram) > 0.3) {
+      contexts.push(`MACD ${indicators.macd.histogram > 0 ? "bullish" : "bearish"} momentum`);
+    }
+    const confLevel = signal.confidence > 0.7 ? "HIGH" : signal.confidence > 0.5 ? "MEDIUM" : "LOW";
+    contexts.push(`Confidence: ${confLevel}`);
+    return contexts.join(" | ");
+  }
+  generateAnalysis(strategy, indicators, pair) {
+    const analyses = [];
+    if (indicators.rsi > 70) {
+      analyses.push(`RSI at ${indicators.rsi.toFixed(1)} - overbought territory, watching for reversal`);
+    } else if (indicators.rsi < 30) {
+      analyses.push(`RSI at ${indicators.rsi.toFixed(1)} - oversold, potential bounce setup`);
+    } else if (indicators.rsi > 55) {
+      analyses.push(`RSI trending bullish at ${indicators.rsi.toFixed(1)}`);
+    } else {
+      analyses.push(`RSI neutral at ${indicators.rsi.toFixed(1)}, no clear direction`);
+    }
+    if (indicators.macd.histogram > 0.5) {
+      analyses.push("MACD histogram expanding positive - momentum building");
+    } else if (indicators.macd.histogram < -0.5) {
+      analyses.push("MACD histogram expanding negative - bearish pressure");
+    }
+    if (indicators.ema.crossover === "golden") {
+      analyses.push("EMA golden cross detected - strong bullish signal");
+    } else if (indicators.ema.crossover === "death") {
+      analyses.push("EMA death cross detected - bearish warning");
+    }
+    if (indicators.bollinger.position > 90) {
+      analyses.push(`Price near upper Bollinger band (${indicators.bollinger.position.toFixed(0)}%) - potential resistance`);
+    } else if (indicators.bollinger.position < 10) {
+      analyses.push(`Price near lower Bollinger band (${indicators.bollinger.position.toFixed(0)}%) - potential support`);
+    }
+    if (indicators.volume.ratio > 1.8) {
+      analyses.push(`Volume spike ${indicators.volume.ratio.toFixed(1)}x average - high activity`);
+    }
+    return analyses.length > 0 ? analyses.join(" | ") : `${pair} consolidating - waiting for clearer setup`;
+  }
+  evaluateSignal(strategy, indicators) {
+    let bullScore = 0;
+    let bearScore = 0;
+    const reasons = [];
+    if (indicators.rsi < 30) {
+      bullScore += 2;
+      reasons.push("RSI oversold");
+    } else if (indicators.rsi < 40) {
+      bullScore += 1;
+      reasons.push("RSI low");
+    } else if (indicators.rsi > 70) {
+      bearScore += 2;
+      reasons.push("RSI overbought");
+    } else if (indicators.rsi > 60) {
+      bearScore += 1;
+      reasons.push("RSI high");
+    }
+    if (indicators.macd.histogram > 0.3) {
+      bullScore += 1.5;
+      reasons.push("MACD bullish");
+    } else if (indicators.macd.histogram < -0.3) {
+      bearScore += 1.5;
+      reasons.push("MACD bearish");
+    }
+    if (indicators.ema.crossover === "golden") {
+      bullScore += 2.5;
+      reasons.push("Golden cross");
+    } else if (indicators.ema.crossover === "death") {
+      bearScore += 2.5;
+      reasons.push("Death cross");
+    } else if (indicators.ema.short > indicators.ema.long) {
+      bullScore += 0.5;
+    } else {
+      bearScore += 0.5;
+    }
+    if (indicators.bollinger.position < 15) {
+      bullScore += 1;
+      reasons.push("BB support");
+    } else if (indicators.bollinger.position > 85) {
+      bearScore += 1;
+      reasons.push("BB resistance");
+    }
+    if (indicators.volume.ratio > 1.5) {
+      if (bullScore > bearScore) bullScore += 1;
+      else bearScore += 1;
+      reasons.push("Volume confirms");
+    }
+    const netScore = bullScore - bearScore;
+    const confidence = Math.min(Math.abs(netScore) / 6, 0.95);
+    const threshold = strategy.riskTolerance === "high" ? 1.5 : strategy.riskTolerance === "medium" ? 2 : 2.5;
+    if (Math.random() > strategy.tradeFrequency) {
+      return { direction: "HOLD", confidence: 0, reason: "Cycle skip" };
+    }
+    if (netScore > threshold) {
+      return { direction: "LONG", confidence, reason: reasons.slice(0, 3).join(", ") };
+    } else if (netScore < -threshold) {
+      return { direction: "SHORT", confidence, reason: reasons.slice(0, 3).join(", ") };
+    }
+    return { direction: "HOLD", confidence: 0, reason: "No clear signal" };
+  }
+  makeTradeDecision(strategy, signal, state) {
+    if (state.openPositions.length >= 3) {
+      return { execute: false, positionSize: 0, leverage: 0, riskReward: 0, reason: "Max positions reached (3)" };
+    }
+    const minConfidence = strategy.riskTolerance === "high" ? 0.3 : strategy.riskTolerance === "medium" ? 0.45 : 0.6;
+    if (signal.confidence < minConfidence) {
+      return { execute: false, positionSize: 0, leverage: 0, riskReward: 0, reason: `Confidence too low (${(signal.confidence * 100).toFixed(0)}% < ${(minConfidence * 100).toFixed(0)}%)` };
+    }
+    const positionSize = rand3(strategy.positionSizeMin, strategy.positionSizeMax);
+    const leverage = randInt3(strategy.leverageMin, strategy.leverageMax);
+    const riskReward = rand3(1.2, 3.5);
+    return { execute: true, positionSize, leverage, riskReward, reason: "" };
+  }
+};
+var botSimulationEngine = new BotSimulationEngine();
+
 exports.OneEngineClient = OneEngineClient;
 exports.PriceService = PriceService;
+exports.STRATEGY_PERSONALITIES = STRATEGY_PERSONALITIES;
 exports.SupabaseService = SupabaseService;
 exports.UsageService = UsageService;
+exports.botSimulationEngine = botSimulationEngine;
 exports.createOneEngineClient = createOneEngineClient;
 exports.createSupabaseClient = createSupabaseClient;
 exports.createUsageService = createUsageService;
+exports.forexSimulationEngine = forexSimulationEngine;
 exports.getSupabaseClient = getSupabaseClient;
 exports.getUsageService = getUsageService;
 exports.priceService = priceService;