v0.6.1: Market simulation with realistic prices

C++ AITraderActor now uses per-symbol reference prices matching real
market levels instead of hardcoded 100-200 range. Dashboard adds
MarketSimulator thread that auto-generates orders and crossing trades
every 30s when session is active. Config updated with all 7 symbols.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.16)
-project(EuNEx VERSION 0.6.0 LANGUAGES CXX)
+project(EuNEx VERSION 0.6.1 LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

README.md

@@ -219,7 +219,8 @@ EuNEx/
 2. ~~Kafka persistence~~ ✓ KafkaStore + Docker Compose (KRaft mode)
 3. ~~FIX gateway~~ ✓ C++ FIXAcceptorActor + Python fallback
 4. ~~Clearing House~~ ✓ ClearingHouseActor + AITraderActor
-5. **SBE encoding** — replace event structs with SBE-encoded messages
-6. **Master/Mirror failover** — implement full Recovery replay on Mirror node
-7. **Trading phases** — pre-open, uncrossing, continuous, close, TAL
-8. **Additional order types** — Stop, Pegged, Mid-Point, Iceberg
+5. ~~Market simulation~~ ✓ Realistic AI trading + Dashboard auto-simulation
+6. **SBE encoding** — replace event structs with SBE-encoded messages
+7. **Master/Mirror failover** — implement full Recovery replay on Mirror node
+8. **Trading phases** — pre-open, uncrossing, continuous, close, TAL
+9. **Additional order types** — Stop, Pegged, Mid-Point, Iceberg

dashboard/app.py

@@ -18,6 +18,7 @@ import json
 import time
 import queue
 import threading
+import random
 import sys
 import os
 import urllib.request
@@ -30,7 +31,7 @@ from dashboard.database import (
     init_db, save_order, save_trade, record_ohlcv,
     get_ohlcv, get_recent_orders, get_recent_trades, get_active_orders,
 )
-from shared.config import SYMBOLS, DASHBOARD_PORT, DASHBOARD_DB, CH_URL
+from shared.config import SYMBOLS, DASHBOARD_PORT, DASHBOARD_DB, CH_URL, SIM_INTERVAL, SIM_ORDERS_PER_ROUND
 
 app = Flask(__name__)
 
@@ -397,6 +398,7 @@ def session_start():
     session_status = "active"
     broadcast_event("session", {"status": session_status})
     _notify_ch("start")
+    _seed_initial_orders()
     return jsonify({"status": session_status})
 
 @app.route("/session/suspend", methods=["POST"])
@@ -428,6 +430,18 @@ def session_status_route():
     return jsonify({"status": session_status})
 
 
+def _seed_initial_orders():
+    for sym_id, info in symbols.items():
+        ref = info["startPrice"]
+        for offset, qty in [(-0.50, 150), (-1.00, 100), (0.50, 200), (1.00, 100)]:
+            side = "Buy" if offset < 0 else "Sell"
+            engine.submit_order(
+                symbol_id=sym_id, side=side, order_type="Limit",
+                price=round(ref + offset, 2), quantity=qty,
+                tif="Day", source="seed",
+            )
+
+
 def _notify_ch(action):
     try:
         data = json.dumps({"action": action}).encode()
@@ -442,10 +456,99 @@ def _notify_ch(action):
         pass
 
 
+# ── Market Simulation ──────────────────────────────────────────────
+
+class MarketSimulator:
+    def __init__(self, engine_ref, interval=SIM_INTERVAL, orders_per_round=SIM_ORDERS_PER_ROUND):
+        self.engine = engine_ref
+        self.interval = interval
+        self.orders_per_round = orders_per_round
+        self._thread = None
+        self._running = False
+        self._ref_prices = {sid: info["startPrice"] for sid, info in symbols.items()}
+
+    def start(self):
+        if self._running:
+            return
+        self._running = True
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        self._running = False
+
+    def _run(self):
+        while self._running:
+            if session_status == "active":
+                self._round()
+            time.sleep(self.interval)
+
+    def _round(self):
+        sym_ids = list(symbols.keys())
+        random.shuffle(sym_ids)
+
+        for sym_id in sym_ids:
+            ref = self._current_ref(sym_id)
+            for _ in range(self.orders_per_round):
+                side = random.choice(["Buy", "Sell"])
+                spread_pct = random.uniform(-0.005, 0.005)
+                price = round(ref * (1 + spread_pct), 2)
+                if price <= 0:
+                    price = 0.01
+                qty = random.randint(10, 200)
+
+                self.engine.submit_order(
+                    symbol_id=sym_id,
+                    side=side,
+                    order_type="Limit",
+                    price=price,
+                    quantity=qty,
+                    tif="Day",
+                    source="sim",
+                )
+
+            cross_side = random.choice(["Buy", "Sell"])
+            snap = snapshots.get(sym_id, {})
+            if cross_side == "Buy" and snap.get("bestAsk", 0) > 0:
+                cross_price = snap["bestAsk"] + 0.01
+            elif cross_side == "Sell" and snap.get("bestBid", 0) > 0:
+                cross_price = snap["bestBid"] - 0.01
+            else:
+                cross_price = ref
+            if cross_price <= 0:
+                cross_price = 0.01
+            cross_qty = random.randint(10, 50)
+
+            self.engine.submit_order(
+                symbol_id=sym_id,
+                side=cross_side,
+                order_type="Limit",
+                price=round(cross_price, 2),
+                quantity=cross_qty,
+                tif="Day",
+                source="sim",
+            )
+
+    def _current_ref(self, sym_id):
+        snap = snapshots.get(sym_id, {})
+        bid = snap.get("bestBid", 0)
+        ask = snap.get("bestAsk", 0)
+        if bid > 0 and ask > 0:
+            return (bid + ask) / 2
+        if snap.get("lastPrice", 0) > 0:
+            return snap["lastPrice"]
+        return self._ref_prices.get(sym_id, 100.0)
+
+
+simulator = MarketSimulator(engine)
+
+
 if __name__ == "__main__":
     os.makedirs(os.path.dirname(db_path), exist_ok=True)
     init_db(db_path)
+    simulator.start()
     port = DASHBOARD_PORT
     print(f"EuNEx Dashboard starting on http://localhost:{port}")
     print(f"  Database: {db_path}")
+    print(f"  Simulation: every {SIM_INTERVAL}s, {SIM_ORDERS_PER_ROUND} orders/symbol/round")
     app.run(host="0.0.0.0", port=port, debug=True, threaded=True)

docs/developers-guide.md

@@ -1,6 +1,6 @@
 # EuNEx Developers Guide
 
-**Version 0.6.0** | Euronext Optiq-Modeled Exchange Simulator
+**Version 0.6.1** | Euronext Optiq-Modeled Exchange Simulator
 
 ---
 
@@ -19,10 +19,11 @@
 11. [FIX Protocol Gateway](#11-fix-protocol-gateway)
 12. [Clearing House](#12-clearing-house)
 13. [AI Trading Members](#13-ai-trading-members)
-14. [Project Structure](#14-project-structure)
-15. [Build & Test](#15-build--test)
-16. [Configuration](#16-configuration)
-17. [Extending EuNEx](#17-extending-eunex)
+14. [Market Simulation](#14-market-simulation)
+15. [Project Structure](#15-project-structure)
+16. [Build & Test](#16-build--test)
+17. [Configuration](#17-configuration)
+18. [Extending EuNEx](#18-extending-eunex)
 
 ---
 
@@ -856,7 +857,63 @@ docker compose up --build
 
 ---
 
-## 14. Project Structure
+## 14. Market Simulation
+
+Both the C++ engine and the Python dashboard include market simulation to continuously generate orders and trades.
+
+### C++ Engine (AITraderActor)
+
+The `AITraderActor` generates orders every ~3 seconds per round. Each of the 10 AI members picks a random symbol and applies its strategy (Momentum, Mean Reversion, or Random). All strategies use per-symbol **reference prices** matching real market levels:
+
+| Symbol | Reference Price |
+|--------|----------------|
+| AAPL   | $154.00        |
+| MSFT   | $324.00        |
+| GOOGL  | $141.00        |
+| TSLA   | $375.00        |
+| NVDA   | $201.00        |
+| AMD    | $320.00        |
+| ENX    | €146.00        |
+
+When no BBO data is available yet, the fallback `submitOrder()` generates prices within ±3 ticks of the reference price instead of random values.
+
+### Python Dashboard (MarketSimulator)
+
+The dashboard runs a `MarketSimulator` thread that generates orders when the session status is `"active"`:
+
+```
+ Configuration (shared/config.py):
+   SIM_INTERVAL           = 30s    (env: EUNEX_SIM_INTERVAL)
+   SIM_ORDERS_PER_ROUND   = 4      (env: EUNEX_SIM_ORDERS)
+
+ Per round (every SIM_INTERVAL seconds):
+   For each of 7 symbols:
+     1. Submit SIM_ORDERS_PER_ROUND limit orders near current mid price (±0.5%)
+     2. Submit 1 crossing order that will match against the book
+     → Generates resting orders + at least 1 trade per symbol per round
+```
+
+**Order flow:**
+- Session "Start Day" → seeds initial orders (2 bid + 2 ask per symbol)
+- Simulation thread wakes every 30s → submits ~35 orders → ~7 trades
+- All trades are persisted to SQLite (trades table + OHLCV aggregation)
+- Dashboard chart shows candlestick data from OHLCV buckets
+
+### Seed Orders (Session Start)
+
+When the dashboard session starts, 4 orders are seeded per symbol to establish a market:
+
+```
+ For each symbol at startPrice:
+   Buy  @ startPrice - 1.00, qty=100
+   Buy  @ startPrice - 0.50, qty=150
+   Sell @ startPrice + 0.50, qty=200
+   Sell @ startPrice + 1.00, qty=100
+```
+
+---
+
+## 15. Project Structure
 
 ```
  EuNEx/
@@ -918,7 +975,7 @@ docker compose up --build
 
 ---
 
-## 15. Build & Test
+## 16. Build & Test
 
 ### Prerequisites
 
@@ -977,7 +1034,7 @@ cd build && ctest -C Release --output-on-failure
 
 ---
 
-## 16. Configuration
+## 17. Configuration
 
 ### Runtime Configuration (main.cpp)
 
@@ -1006,7 +1063,7 @@ The engine pre-populates order books with spread-defining orders:
 
 ---
 
-## 17. Extending EuNEx
+## 18. Extending EuNEx
 
 ### Adding a New Symbol
 
@@ -1055,7 +1112,7 @@ The engine pre-populates order books with spread-defining orders:
  ✓ Clearing house + AI traders     □ EuroCCP/LCH integration
  ✓ IACA fragments                  □ IACA FINISH + COPY + IDS
  ✓ Python bridge (JSON)            □ SBE multicast MDG
-                                    □ Dashboard ticker + charts
+ ✓ Market simulation (C++ + Py)    □ Dashboard ticker + charts
                                     □ AI analyst (Ollama/Llama)
                                     □ SQLite trade persistence
                                     □ Developer message visualizer

shared/config.py

@@ -27,12 +27,19 @@ KAFKA_TOPIC_CONTROL = "eunex.control"
 
 # ── Symbols ────────────────────────────────────────────────────────
 SYMBOLS = {
-    1: {"name": "AAPL", "segment": "EQU", "startPrice": 185.0, "tickSize": 0.01, "lotSize": 1},
-    2: {"name": "MSFT", "segment": "EQU", "startPrice": 420.0, "tickSize": 0.01, "lotSize": 1},
-    3: {"name": "GOOGL", "segment": "EQU", "startPrice": 175.0, "tickSize": 0.01, "lotSize": 1},
-    4: {"name": "EURO50", "segment": "EQD", "startPrice": 5050.0, "tickSize": 0.5, "lotSize": 1},
+    1: {"name": "AAPL",  "segment": "EQU", "startPrice": 154.0,  "tickSize": 0.01, "lotSize": 1},
+    2: {"name": "MSFT",  "segment": "EQU", "startPrice": 324.0,  "tickSize": 0.01, "lotSize": 1},
+    3: {"name": "GOOGL", "segment": "EQU", "startPrice": 141.0,  "tickSize": 0.01, "lotSize": 1},
+    4: {"name": "TSLA",  "segment": "EQU", "startPrice": 375.0,  "tickSize": 0.01, "lotSize": 1},
+    5: {"name": "NVDA",  "segment": "EQU", "startPrice": 201.0,  "tickSize": 0.01, "lotSize": 1},
+    6: {"name": "AMD",   "segment": "EQU", "startPrice": 320.0,  "tickSize": 0.01, "lotSize": 1},
+    7: {"name": "ENX",   "segment": "EQU", "startPrice": 146.0,  "tickSize": 0.01, "lotSize": 1},
 }
 
+# ── Simulation ─────────────────────────────────────────────────────
+SIM_INTERVAL = int(os.environ.get("EUNEX_SIM_INTERVAL", 30))
+SIM_ORDERS_PER_ROUND = int(os.environ.get("EUNEX_SIM_ORDERS", 4))
+
 # ── Clearing House ─────────────────────────────────────────────────
 CH_MEMBERS = {
     f"MBR{i:02d}": {"capital": 100_000.0} for i in range(1, 11)

src/actors/AITraderActor.cpp

@@ -89,13 +89,30 @@ void AITraderActor::tradeRound() {
     }
 }
 
+Price_t AITraderActor::referencePrice(SymbolIndex_t sym) {
+    switch (sym) {
+        case 1: return toFixedPrice(154.0);  // AAPL
+        case 2: return toFixedPrice(324.0);  // MSFT
+        case 3: return toFixedPrice(141.0);  // GOOGL
+        case 4: return toFixedPrice(375.0);  // TSLA
+        case 5: return toFixedPrice(201.0);  // NVDA
+        case 6: return toFixedPrice(320.0);  // AMD
+        case 7: return toFixedPrice(146.0);  // ENX
+        default: return toFixedPrice(100.0);
+    }
+}
+
 void AITraderActor::submitOrder(const AITraderMember& member, SymbolIndex_t symIdx) {
     std::uniform_int_distribution<int> sideDist(0, 1);
-    std::uniform_int_distribution<int> priceDist(100, 200);
     std::uniform_int_distribution<int> qtyDist(10, 100);
 
     Side side = sideDist(rng_) ? Side::Buy : Side::Sell;
-    Price_t price = toFixedPrice(priceDist(rng_) * 1.0);
+    Price_t refPrice = referencePrice(symIdx);
+    std::uniform_int_distribution<int> spreadDist(-3, 3);
+    Price_t tickOffset = spreadDist(rng_) * (PRICE_SCALE / 100);
+    Price_t price = refPrice + tickOffset;
+    if (price <= 0) price = PRICE_SCALE;
+
     Quantity_t qty = qtyDist(rng_);
     ClOrdId_t clOrdId = nextClOrdId_++;
 
@@ -159,7 +176,7 @@ void AITraderActor::strategyRandom(const AITraderMember& member, SymbolIndex_t s
     Side side = sideDist(rng_) ? Side::Buy : Side::Sell;
 
     Price_t midPrice = (bbo.bestBid + bbo.bestAsk) / 2;
-    if (midPrice == 0) midPrice = toFixedPrice(150.0);
+    if (midPrice == 0) midPrice = referencePrice(symIdx);
 
     std::uniform_int_distribution<int> spreadDist(-5, 5);
     Price_t tickOffset = spreadDist(rng_) * (PRICE_SCALE / 100);

src/actors/AITraderActor.hpp

@@ -55,6 +55,8 @@ private:
     static constexpr int TRADE_INTERVAL_MS = 30000;
     static constexpr int MAX_PRICE_HISTORY = 50;
 
+    static Price_t referencePrice(SymbolIndex_t sym);
+
     tredzone::Actor::Event::Pipe oePipe_;
     std::vector<SymbolIndex_t> symbols_;
     std::vector<AITraderMember> members_;