v0.4.0: C++ FIX Gateway, Clearing House & AI Trader actors

Implement FIX gateway, Clearing House, and AI traders as proper C++
actors matching the Optiq architecture, replacing the Python-only
approach from v0.3.0.

New actors:
- FIXGatewayActor: C++ TCP FIX 4.4 acceptor (Logon, NewOrder, Cancel, Amend)
- ClearingHouseActor: Trade clearing, member positions, leaderboard
- AITraderActor: 10 members (MBR01-10) with momentum/mean_revert/random strategies

Changes:
- OrderBook: Trade now carries buySessionId/sellSessionId
- OrderBookActor: Optional clearing house pipe for trade forwarding
- OEGatewayActor: NewOrderEvent handler + exec report subscriber forwarding
- main.cpp: Full 4-core topology (OEG+FIX, Books, MarketData, CH+AI)
- SocketCompat.hpp: Cross-platform socket abstraction (winsock2/POSIX)
- CMakeLists.txt: New sources, ws2_32 on Windows, 3 new test targets
- 6 test suites (44 tests total), all passing

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.2.0 LANGUAGES CXX)
+project(EuNEx VERSION 0.4.0 LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -54,6 +54,9 @@ set(EUNEX_CORE_SOURCES
     src/actors/OrderBookActor.cpp
     src/actors/OEGatewayActor.cpp
     src/actors/MarketDataActor.cpp
+    src/actors/ClearingHouseActor.cpp
+    src/actors/FIXGatewayActor.cpp
+    src/actors/AITraderActor.cpp
     src/recovery/RecoveryProxy.cpp
     src/iaca/IacaAggregator.cpp
 )
@@ -69,6 +72,11 @@ endif()
 find_package(Threads REQUIRED)
 target_link_libraries(eunex_core PUBLIC Threads::Threads)
 
+# Windows socket library
+if(WIN32)
+    target_link_libraries(eunex_core PUBLIC ws2_32)
+endif()
+
 # ── Main executable ─────────────────────────────────────────────────
 add_executable(eunex_me src/main.cpp)
 target_link_libraries(eunex_me PRIVATE eunex_core)
@@ -97,4 +105,16 @@ if(EUNEX_BUILD_TESTS)
     add_executable(test_threaded_engine tests/test_threaded_engine.cpp)
     target_link_libraries(test_threaded_engine PRIVATE eunex_core)
     add_test(NAME ThreadedEngineTest COMMAND test_threaded_engine)
+
+    add_executable(test_clearing_house tests/test_clearing_house.cpp)
+    target_link_libraries(test_clearing_house PRIVATE eunex_core)
+    add_test(NAME ClearingHouseTest COMMAND test_clearing_house)
+
+    add_executable(test_fix_gateway tests/test_fix_gateway.cpp)
+    target_link_libraries(test_fix_gateway PRIVATE eunex_core)
+    add_test(NAME FIXGatewayTest COMMAND test_fix_gateway)
+
+    add_executable(test_ai_trader tests/test_ai_trader.cpp)
+    target_link_libraries(test_ai_trader PRIVATE eunex_core)
+    add_test(NAME AITraderTest COMMAND test_ai_trader)
 endif()

src/actors/AITraderActor.cpp

@@ -0,0 +1,183 @@
+#include "actors/AITraderActor.hpp"
+#include <algorithm>
+#include <numeric>
+#include <cstring>
+#include <iostream>
+
+namespace eunex {
+
+AITraderActor::AITraderActor(const tredzone::ActorId& oeGatewayId,
+                              const std::vector<SymbolIndex_t>& symbols)
+    : oePipe_(*this, oeGatewayId)
+    , symbols_(symbols)
+    , rng_(std::random_device{}())
+{
+    registerEventHandler<BookUpdateEvent>(*this);
+    registerEventHandler<TradeEvent>(*this);
+    registerEventHandler<ExecReportEvent>(*this);
+    initMembers();
+    registerCallback(*this);
+}
+
+void AITraderActor::initMembers() {
+    Strategy strategies[] = {Strategy::Momentum, Strategy::MeanReversion, Strategy::Random};
+
+    for (int i = 0; i < NUM_MEMBERS; ++i) {
+        AITraderMember m{};
+        m.memberId = static_cast<MemberId_t>(i + 1);
+        m.sessionId = static_cast<SessionId_t>(200 + i);
+        std::snprintf(m.name, sizeof(m.name), "MBR%02d", i + 1);
+        m.strategy = strategies[i % 3];
+        m.orderCount = 0;
+        members_.push_back(m);
+    }
+}
+
+void AITraderActor::onEvent(const BookUpdateEvent& event) {
+    BBO bbo{};
+    if (event.bidDepth > 0) bbo.bestBid = event.bids[0].price;
+    if (event.askDepth > 0) bbo.bestAsk = event.asks[0].price;
+    bbos_[event.symbolIdx] = bbo;
+}
+
+void AITraderActor::onEvent(const TradeEvent& event) {
+    auto& history = priceHistory_[event.trade.symbolIdx];
+    history.push_back(event.trade.price);
+    if (history.size() > MAX_PRICE_HISTORY) {
+        history.erase(history.begin());
+    }
+}
+
+void AITraderActor::onEvent(const ExecReportEvent&) {
+    // Could track fills per member; not needed for basic trading
+}
+
+void AITraderActor::onCallback() {
+    tradeRound();
+    registerCallback(*this);
+}
+
+void AITraderActor::tradeRound() {
+    if (symbols_.empty()) return;
+
+    for (auto& member : members_) {
+        std::uniform_int_distribution<size_t> symDist(0, symbols_.size() - 1);
+        SymbolIndex_t symIdx = symbols_[symDist(rng_)];
+
+        auto bboIt = bbos_.find(symIdx);
+        if (bboIt == bbos_.end() || (bboIt->second.bestBid == 0 && bboIt->second.bestAsk == 0)) {
+            submitOrder(member, symIdx);
+            continue;
+        }
+
+        const BBO& bbo = bboIt->second;
+        auto histIt = priceHistory_.find(symIdx);
+        std::vector<Price_t> emptyHist;
+        const auto& history = (histIt != priceHistory_.end()) ? histIt->second : emptyHist;
+
+        switch (member.strategy) {
+            case Strategy::Momentum:
+                strategyMomentum(member, symIdx, bbo, history);
+                break;
+            case Strategy::MeanReversion:
+                strategyMeanReversion(member, symIdx, bbo, history);
+                break;
+            case Strategy::Random:
+                strategyRandom(member, symIdx, bbo);
+                break;
+        }
+    }
+}
+
+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);
+    Quantity_t qty = qtyDist(rng_);
+    ClOrdId_t clOrdId = nextClOrdId_++;
+
+    oePipe_.push<NewOrderEvent>(clOrdId, symIdx, side, OrderType::Limit,
+                                 TimeInForce::Day, price, qty, member.sessionId);
+}
+
+void AITraderActor::strategyMomentum(const AITraderMember& member, SymbolIndex_t symIdx,
+                                      const BBO& bbo, const std::vector<Price_t>& history) {
+    if (history.size() < 3) {
+        submitOrder(member, symIdx);
+        return;
+    }
+
+    Price_t recent = history.back();
+    Price_t older = history[history.size() - 3];
+
+    Side side = (recent > older) ? Side::Buy : Side::Sell;
+    Price_t midPrice = (bbo.bestBid + bbo.bestAsk) / 2;
+    if (midPrice == 0) midPrice = recent;
+
+    std::uniform_int_distribution<int> spreadDist(-2, 2);
+    Price_t tickOffset = spreadDist(rng_) * (PRICE_SCALE / 100);
+    Price_t price = midPrice + tickOffset;
+    if (price <= 0) price = PRICE_SCALE;
+
+    std::uniform_int_distribution<int> qtyDist(10, 50);
+    Quantity_t qty = qtyDist(rng_);
+    ClOrdId_t clOrdId = nextClOrdId_++;
+
+    oePipe_.push<NewOrderEvent>(clOrdId, symIdx, side, OrderType::Limit,
+                                 TimeInForce::Day, price, qty, member.sessionId);
+}
+
+void AITraderActor::strategyMeanReversion(const AITraderMember& member, SymbolIndex_t symIdx,
+                                           const BBO& bbo, const std::vector<Price_t>& history) {
+    if (history.size() < 5) {
+        submitOrder(member, symIdx);
+        return;
+    }
+
+    int64_t sum = 0;
+    for (auto p : history) sum += p;
+    Price_t mean = static_cast<Price_t>(sum / static_cast<int64_t>(history.size()));
+    Price_t current = history.back();
+
+    Side side = (current > mean) ? Side::Sell : Side::Buy;
+
+    Price_t price = mean;
+    std::uniform_int_distribution<int> qtyDist(10, 50);
+    Quantity_t qty = qtyDist(rng_);
+    ClOrdId_t clOrdId = nextClOrdId_++;
+
+    oePipe_.push<NewOrderEvent>(clOrdId, symIdx, side, OrderType::Limit,
+                                 TimeInForce::Day, price, qty, member.sessionId);
+}
+
+void AITraderActor::strategyRandom(const AITraderMember& member, SymbolIndex_t symIdx,
+                                    const BBO& bbo) {
+    std::uniform_int_distribution<int> sideDist(0, 1);
+    Side side = sideDist(rng_) ? Side::Buy : Side::Sell;
+
+    Price_t midPrice = (bbo.bestBid + bbo.bestAsk) / 2;
+    if (midPrice == 0) midPrice = toFixedPrice(150.0);
+
+    std::uniform_int_distribution<int> spreadDist(-5, 5);
+    Price_t tickOffset = spreadDist(rng_) * (PRICE_SCALE / 100);
+    Price_t price = midPrice + tickOffset;
+    if (price <= 0) price = PRICE_SCALE;
+
+    std::uniform_int_distribution<int> qtyDist(5, 100);
+    Quantity_t qty = qtyDist(rng_);
+    ClOrdId_t clOrdId = nextClOrdId_++;
+
+    oePipe_.push<NewOrderEvent>(clOrdId, symIdx, side, OrderType::Limit,
+                                 TimeInForce::Day, price, qty, member.sessionId);
+}
+
+int AITraderActor::totalOrderCount() const {
+    int total = 0;
+    for (auto& m : members_) total += m.orderCount;
+    return total;
+}
+
+} // namespace eunex

src/actors/AITraderActor.hpp

@@ -0,0 +1,84 @@
+#pragma once
+// ════════════════════════════════════════════════════════════════════
+// AITraderActor — Automated trading members
+//
+// Optiq equivalent: Clearing House member trading obligations
+//
+// 10 AI members (MBR01-MBR10) with 3 strategies:
+//   momentum, mean_reversion, random
+//
+// Uses Actor::Callback for periodic trading decisions (~30s intervals).
+// Receives BookUpdateEvent for BBO data and TradeEvent for price history.
+// Pushes NewOrderEvent to OEGateway.
+// ════════════════════════════════════════════════════════════════════
+
+#include "engine/SimplxShim.hpp"
+#include "actors/Events.hpp"
+#include <vector>
+#include <random>
+#include <string>
+#include <unordered_map>
+
+namespace eunex {
+
+enum class Strategy : uint8_t {
+    Momentum = 0,
+    MeanReversion = 1,
+    Random = 2
+};
+
+struct AITraderMember {
+    MemberId_t  memberId;
+    SessionId_t sessionId;
+    char        name[8];
+    Strategy    strategy;
+    int         orderCount;
+};
+
+class AITraderActor : public tredzone::Actor, public tredzone::Actor::Callback {
+public:
+    struct Service : tredzone::AsyncService {};
+
+    AITraderActor(const tredzone::ActorId& oeGatewayId,
+                  const std::vector<SymbolIndex_t>& symbols);
+
+    void onEvent(const BookUpdateEvent& event);
+    void onEvent(const TradeEvent& event);
+    void onEvent(const ExecReportEvent& event);
+
+    void onCallback() override;
+
+    int totalOrderCount() const;
+
+private:
+    static constexpr int NUM_MEMBERS = 10;
+    static constexpr int TRADE_INTERVAL_MS = 30000;
+    static constexpr int MAX_PRICE_HISTORY = 50;
+
+    tredzone::Actor::Event::Pipe oePipe_;
+    std::vector<SymbolIndex_t> symbols_;
+    std::vector<AITraderMember> members_;
+    ClOrdId_t nextClOrdId_ = 50000;
+
+    struct BBO {
+        Price_t bestBid = 0;
+        Price_t bestAsk = 0;
+    };
+    std::unordered_map<SymbolIndex_t, BBO> bbos_;
+    std::unordered_map<SymbolIndex_t, std::vector<Price_t>> priceHistory_;
+
+    std::mt19937 rng_;
+
+    void initMembers();
+    void tradeRound();
+    void submitOrder(const AITraderMember& member, SymbolIndex_t symIdx);
+
+    void strategyMomentum(const AITraderMember& member, SymbolIndex_t symIdx,
+                          const BBO& bbo, const std::vector<Price_t>& history);
+    void strategyMeanReversion(const AITraderMember& member, SymbolIndex_t symIdx,
+                               const BBO& bbo, const std::vector<Price_t>& history);
+    void strategyRandom(const AITraderMember& member, SymbolIndex_t symIdx,
+                        const BBO& bbo);
+};
+
+} // namespace eunex

src/actors/ClearingHouseActor.cpp

@@ -0,0 +1,120 @@
+#include "actors/ClearingHouseActor.hpp"
+#include <cstring>
+#include <algorithm>
+
+namespace eunex {
+
+ClearingHouseActor::ClearingHouseActor() {
+    registerEventHandler<TradeEvent>(*this);
+    initMembers();
+}
+
+void ClearingHouseActor::initMembers() {
+    for (int i = 0; i < NUM_MEMBERS; ++i) {
+        MemberId_t id = static_cast<MemberId_t>(i + 1);
+        MemberState ms{};
+        ms.memberId = id;
+        std::snprintf(ms.name, sizeof(ms.name), "MBR%02d", i + 1);
+        ms.capital = INITIAL_CAPITAL;
+        ms.initialCapital = INITIAL_CAPITAL;
+        ms.tradeCount = 0;
+        ms.distinctSymbols = 0;
+        members_[id] = std::move(ms);
+    }
+}
+
+void ClearingHouseActor::mapSession(SessionId_t sessionId, MemberId_t memberId) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    sessionToMember_[sessionId] = memberId;
+}
+
+void ClearingHouseActor::onEvent(const TradeEvent& event) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    const Trade& t = event.trade;
+
+    auto buyIt = sessionToMember_.find(t.buySessionId);
+    if (buyIt != sessionToMember_.end()) {
+        processTradeSide(buyIt->second, t.symbolIdx, t.price, t.quantity, true);
+    }
+
+    auto sellIt = sessionToMember_.find(t.sellSessionId);
+    if (sellIt != sessionToMember_.end()) {
+        processTradeSide(sellIt->second, t.symbolIdx, t.price, t.quantity, false);
+    }
+}
+
+void ClearingHouseActor::processTradeSide(MemberId_t memberId, SymbolIndex_t symbolIdx,
+                                           Price_t price, Quantity_t qty, bool isBuy) {
+    auto it = members_.find(memberId);
+    if (it == members_.end()) return;
+
+    MemberState& m = it->second;
+    m.tradeCount++;
+
+    double cost = toDouble(price) * static_cast<double>(qty);
+
+    if (isBuy) {
+        m.capital -= cost;
+    } else {
+        m.capital += cost;
+    }
+
+    auto hIt = m.holdings.find(symbolIdx);
+    if (hIt == m.holdings.end()) {
+        MemberHolding h{};
+        h.symbolIdx = symbolIdx;
+        h.quantity = isBuy ? static_cast<int64_t>(qty) : -static_cast<int64_t>(qty);
+        h.avgCost = price;
+        m.holdings[symbolIdx] = h;
+        m.distinctSymbols = static_cast<int>(m.holdings.size());
+    } else {
+        MemberHolding& h = hIt->second;
+        if (isBuy) {
+            double prevCost = toDouble(h.avgCost) * static_cast<double>(std::abs(h.quantity));
+            h.quantity += static_cast<int64_t>(qty);
+            if (h.quantity != 0) {
+                h.avgCost = toFixedPrice((prevCost + cost) / static_cast<double>(std::abs(h.quantity)));
+            }
+        } else {
+            h.quantity -= static_cast<int64_t>(qty);
+            if (h.quantity == 0) {
+                m.holdings.erase(hIt);
+                m.distinctSymbols = static_cast<int>(m.holdings.size());
+            }
+        }
+    }
+}
+
+std::vector<LeaderboardEntry> ClearingHouseActor::getLeaderboard() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    std::vector<LeaderboardEntry> entries;
+    entries.reserve(members_.size());
+
+    for (auto& [id, ms] : members_) {
+        LeaderboardEntry e{};
+        e.memberId = ms.memberId;
+        std::memcpy(e.name, ms.name, sizeof(e.name));
+        e.capital = ms.capital;
+        e.pnl = ms.capital - ms.initialCapital;
+        e.tradeCount = ms.tradeCount;
+        e.holdingCount = static_cast<int>(ms.holdings.size());
+        entries.push_back(e);
+    }
+
+    std::sort(entries.begin(), entries.end(),
+              [](const LeaderboardEntry& a, const LeaderboardEntry& b) {
+                  return a.capital > b.capital;
+              });
+
+    return entries;
+}
+
+const MemberState* ClearingHouseActor::getMember(MemberId_t id) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto it = members_.find(id);
+    return (it != members_.end()) ? &it->second : nullptr;
+}
+
+} // namespace eunex

src/actors/ClearingHouseActor.hpp

@@ -0,0 +1,68 @@
+#pragma once
+// ════════════════════════════════════════════════════════════════════
+// ClearingHouseActor — Trade clearing and member position management
+//
+// Optiq equivalent: Clearing House downstream from Kafka Bus / PTB
+//
+// Receives TradeEvent from OrderBookActor(s), attributes trades to
+// members via SessionId→MemberId mapping, maintains capital and
+// holdings per member. Exposes thread-safe getLeaderboard() for
+// the Python bridge to read.
+// ════════════════════════════════════════════════════════════════════
+
+#include "engine/SimplxShim.hpp"
+#include "actors/Events.hpp"
+#include <unordered_map>
+#include <vector>
+#include <mutex>
+#include <string>
+
+namespace eunex {
+
+struct MemberState {
+    MemberId_t  memberId;
+    char        name[8];
+    double      capital;
+    double      initialCapital;
+    int         tradeCount;
+    int         distinctSymbols;
+    std::unordered_map<SymbolIndex_t, MemberHolding> holdings;
+};
+
+struct LeaderboardEntry {
+    MemberId_t  memberId;
+    char        name[8];
+    double      capital;
+    double      pnl;
+    int         tradeCount;
+    int         holdingCount;
+};
+
+class ClearingHouseActor : public tredzone::Actor {
+public:
+    struct Service : tredzone::AsyncService {};
+
+    ClearingHouseActor();
+
+    void onEvent(const TradeEvent& event);
+
+    void mapSession(SessionId_t sessionId, MemberId_t memberId);
+
+    std::vector<LeaderboardEntry> getLeaderboard() const;
+
+    const MemberState* getMember(MemberId_t id) const;
+
+private:
+    static constexpr int NUM_MEMBERS = 10;
+    static constexpr double INITIAL_CAPITAL = 100000.0;
+
+    std::unordered_map<SessionId_t, MemberId_t> sessionToMember_;
+    std::unordered_map<MemberId_t, MemberState> members_;
+    mutable std::mutex mutex_;
+
+    void initMembers();
+    void processTradeSide(MemberId_t memberId, SymbolIndex_t symbolIdx,
+                          Price_t price, Quantity_t qty, bool isBuy);
+};
+
+} // namespace eunex

src/actors/Events.hpp

@@ -86,6 +86,11 @@ struct ExecReportEvent : tredzone::Actor::Event {
           filledQty(rpt.filledQty), remainingQty(rpt.remainingQty),
           lastPrice(rpt.lastPrice), lastQty(rpt.lastQty),
           tradeId(rpt.tradeId), sessionId(sess) {}
+    ExecReportEvent(const ExecReportEvent& other)
+        : orderId(other.orderId), clOrdId(other.clOrdId), status(other.status),
+          filledQty(other.filledQty), remainingQty(other.remainingQty),
+          lastPrice(other.lastPrice), lastQty(other.lastQty),
+          tradeId(other.tradeId), sessionId(other.sessionId) {}
 };
 
 // ── Trade event (OrderBook Actor → MarketData Actor) ───────────────

src/actors/FIXGatewayActor.cpp

@@ -0,0 +1,407 @@
+#include "actors/FIXGatewayActor.hpp"
+#include <iostream>
+#include <sstream>
+#include <cstring>
+#include <chrono>
+#include <iomanip>
+#include <ctime>
+#include <cstdlib>
+
+namespace eunex {
+
+FIXGatewayActor::FIXGatewayActor(const tredzone::ActorId& oeGatewayId, uint16_t port)
+    : oePipe_(*this, oeGatewayId)
+    , port_(port)
+{
+    registerEventHandler<ExecReportEvent>(*this);
+
+    symbolNames_[1] = "AAPL";
+    symbolNames_[2] = "MSFT";
+    symbolNames_[3] = "GOOGL";
+    symbolNames_[4] = "EURO50";
+
+    listenSock_ = socket(AF_INET, SOCK_STREAM, 0);
+    if (listenSock_ == INVALID_SOCK) {
+        std::cerr << "FIXGateway: socket() failed\n";
+        return;
+    }
+
+    setSocketReuseAddr(listenSock_);
+
+    sockaddr_in addr{};
+    addr.sin_family = AF_INET;
+    addr.sin_addr.s_addr = INADDR_ANY;
+    addr.sin_port = htons(port_);
+
+    if (bind(listenSock_, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) != 0) {
+        std::cerr << "FIXGateway: bind() failed on port " << port_ << "\n";
+        closeSocket(listenSock_);
+        listenSock_ = INVALID_SOCK;
+        return;
+    }
+
+    if (listen(listenSock_, 5) != 0) {
+        std::cerr << "FIXGateway: listen() failed\n";
+        closeSocket(listenSock_);
+        listenSock_ = INVALID_SOCK;
+        return;
+    }
+
+    running_ = true;
+    acceptThread_ = std::thread(&FIXGatewayActor::acceptLoop, this);
+
+    std::cout << "FIXGateway: listening on port " << port_ << "\n";
+}
+
+FIXGatewayActor::~FIXGatewayActor() {
+    stop();
+}
+
+void FIXGatewayActor::stop() {
+    if (!running_.exchange(false)) return;
+
+    if (listenSock_ != INVALID_SOCK) {
+        closeSocket(listenSock_);
+        listenSock_ = INVALID_SOCK;
+    }
+
+    if (acceptThread_.joinable()) acceptThread_.join();
+
+    std::lock_guard<std::mutex> lock(sessionMutex_);
+    for (auto& [id, sess] : sessions_) {
+        if (sess->sock != INVALID_SOCK) {
+#ifdef _WIN32
+            shutdown(sess->sock, SD_BOTH);
+#else
+            shutdown(sess->sock, SHUT_RDWR);
+#endif
+            closeSocket(sess->sock);
+            sess->sock = INVALID_SOCK;
+        }
+        if (sess->recvThread.joinable()) sess->recvThread.join();
+    }
+    sessions_.clear();
+}
+
+int FIXGatewayActor::clientCount() const {
+    std::lock_guard<std::mutex> lock(sessionMutex_);
+    return static_cast<int>(sessions_.size());
+}
+
+// ── Accept loop (background thread) ──────────────────────────────
+
+void FIXGatewayActor::acceptLoop() {
+    while (running_) {
+        sockaddr_in clientAddr{};
+        socklen_t len = sizeof(clientAddr);
+        socket_t clientSock = accept(listenSock_,
+                                      reinterpret_cast<sockaddr*>(&clientAddr), &len);
+
+        if (clientSock == INVALID_SOCK) {
+            if (running_) std::cerr << "FIXGateway: accept() failed\n";
+            continue;
+        }
+
+        std::lock_guard<std::mutex> lock(sessionMutex_);
+        SessionId_t sessId = nextSessionId_++;
+
+        auto sess = std::make_unique<FIXSession>();
+        sess->sock = clientSock;
+        sess->sessionId = sessId;
+        sess->msgSeqNum = 1;
+        sess->loggedOn = false;
+
+        FIXSession* raw = sess.get();
+        sess->recvThread = std::thread(&FIXGatewayActor::clientRecvLoop, this, sessId);
+
+        sessions_[sessId] = std::move(sess);
+        std::cout << "FIXGateway: client connected (session " << sessId << ")\n";
+    }
+}
+
+// ── Client recv loop (per-client thread) ─────────────────────────
+
+void FIXGatewayActor::clientRecvLoop(SessionId_t sessionId) {
+    socket_t sock;
+    {
+        std::lock_guard<std::mutex> lock(sessionMutex_);
+        auto it = sessions_.find(sessionId);
+        if (it == sessions_.end()) return;
+        sock = it->second->sock;
+    }
+
+    char buf[4096];
+    std::string buffer;
+
+    while (running_) {
+        int n = recv(sock, buf, sizeof(buf) - 1, 0);
+        if (n <= 0) break;
+
+        buf[n] = '\0';
+        buffer.append(buf, n);
+
+        auto messages = parseFIXMessages(buffer);
+
+        for (auto& msg : messages) {
+            std::string msgType = getTag(msg, 35);
+
+            std::lock_guard<std::mutex> lock(sessionMutex_);
+            auto it = sessions_.find(sessionId);
+            if (it == sessions_.end()) return;
+            FIXSession& sess = *it->second;
+
+            if (msgType == "A") {
+                handleLogon(sess, msg);
+            } else if (msgType == "5") {
+                sendFIX(sess, "5", {});
+                return;
+            } else if (msgType == "0") {
+                sendFIX(sess, "0", {});
+            } else if (msgType == "D") {
+                handleNewOrderSingle(sess, msg);
+            } else if (msgType == "F") {
+                handleCancelRequest(sess, msg);
+            } else if (msgType == "G") {
+                handleCancelReplaceRequest(sess, msg);
+            }
+        }
+    }
+
+    std::lock_guard<std::mutex> lock(sessionMutex_);
+    auto it = sessions_.find(sessionId);
+    if (it != sessions_.end()) {
+        closeSocket(it->second->sock);
+        it->second->sock = INVALID_SOCK;
+    }
+}
+
+// ── FIX message parsing ──────────────────────────────────────────
+
+std::vector<FIXGatewayActor::TagMap> FIXGatewayActor::parseFIXMessages(const std::string& data) {
+    std::vector<TagMap> result;
+    std::string remaining = data;
+
+    while (true) {
+        auto checkPos = remaining.find("10=");
+        if (checkPos == std::string::npos) break;
+
+        auto sohAfterCheck = remaining.find('\x01', checkPos);
+        if (sohAfterCheck == std::string::npos) break;
+
+        std::string rawMsg = remaining.substr(0, sohAfterCheck + 1);
+        remaining = remaining.substr(sohAfterCheck + 1);
+
+        TagMap tags;
+        size_t pos = 0;
+        while (pos < rawMsg.size()) {
+            auto eqPos = rawMsg.find('=', pos);
+            if (eqPos == std::string::npos) break;
+            auto sohPos = rawMsg.find('\x01', eqPos);
+            if (sohPos == std::string::npos) sohPos = rawMsg.size();
+
+            int tag = std::atoi(rawMsg.substr(pos, eqPos - pos).c_str());
+            std::string val = rawMsg.substr(eqPos + 1, sohPos - eqPos - 1);
+            tags[tag] = val;
+            pos = sohPos + 1;
+        }
+
+        if (!tags.empty()) result.push_back(std::move(tags));
+    }
+
+    // Put unparsed data back (caller should update buffer)
+    const_cast<std::string&>(data) = remaining;
+    return result;
+}
+
+std::string FIXGatewayActor::getTag(const TagMap& msg, int tag, const std::string& def) {
+    auto it = msg.find(tag);
+    return (it != msg.end()) ? it->second : def;
+}
+
+// ── FIX message handlers ─────────────────────────────────────────
+
+void FIXGatewayActor::handleLogon(FIXSession& sess, const TagMap& msg) {
+    sess.senderCompId = getTag(msg, 49, "UNKNOWN");
+    sess.loggedOn = true;
+    std::cout << "FIXGateway: Logon from " << sess.senderCompId
+              << " (session " << sess.sessionId << ")\n";
+
+    sendFIX(sess, "A", {
+        {98, "0"},
+        {108, "30"}
+    });
+}
+
+void FIXGatewayActor::handleNewOrderSingle(FIXSession& sess, const TagMap& msg) {
+    std::string clOrdIdStr = getTag(msg, 11);
+    std::string symbol = getTag(msg, 55);
+    std::string sideStr = getTag(msg, 54);
+    std::string ordTypeStr = getTag(msg, 40);
+    std::string priceStr = getTag(msg, 44, "0");
+    std::string qtyStr = getTag(msg, 38);
+    std::string tifStr = getTag(msg, 59, "0");
+
+    ClOrdId_t clOrdId = std::strtoull(clOrdIdStr.c_str(), nullptr, 10);
+    SymbolIndex_t symIdx = symbolFromString(symbol);
+    Side side = (sideStr == "1") ? Side::Buy : Side::Sell;
+    OrderType ordType = (ordTypeStr == "1") ? OrderType::Market : OrderType::Limit;
+    Price_t price = toFixedPrice(std::strtod(priceStr.c_str(), nullptr));
+    Quantity_t qty = std::strtoull(qtyStr.c_str(), nullptr, 10);
+
+    TimeInForce tif = TimeInForce::Day;
+    if (tifStr == "1") tif = TimeInForce::GTC;
+    else if (tifStr == "3") tif = TimeInForce::IOC;
+    else if (tifStr == "4") tif = TimeInForce::FOK;
+
+    oePipe_.push<NewOrderEvent>(clOrdId, symIdx, side, ordType, tif, price, qty, sess.sessionId);
+}
+
+void FIXGatewayActor::handleCancelRequest(FIXSession& sess, const TagMap& msg) {
+    std::string origClOrdIdStr = getTag(msg, 41);
+    std::string orderIdStr = getTag(msg, 37, "0");
+    std::string symbol = getTag(msg, 55);
+
+    ClOrdId_t origClOrdId = std::strtoull(origClOrdIdStr.c_str(), nullptr, 10);
+    OrderId_t orderId = std::strtoull(orderIdStr.c_str(), nullptr, 10);
+    SymbolIndex_t symIdx = symbolFromString(symbol);
+
+    oePipe_.push<CancelOrderEvent>(orderId, origClOrdId, symIdx, sess.sessionId);
+}
+
+void FIXGatewayActor::handleCancelReplaceRequest(FIXSession& sess, const TagMap& msg) {
+    std::string orderIdStr = getTag(msg, 37, "0");
+    std::string origClOrdIdStr = getTag(msg, 41);
+    std::string symbol = getTag(msg, 55);
+    std::string priceStr = getTag(msg, 44, "0");
+    std::string qtyStr = getTag(msg, 38);
+
+    OrderId_t orderId = std::strtoull(orderIdStr.c_str(), nullptr, 10);
+    ClOrdId_t origClOrdId = std::strtoull(origClOrdIdStr.c_str(), nullptr, 10);
+    SymbolIndex_t symIdx = symbolFromString(symbol);
+    Price_t newPrice = toFixedPrice(std::strtod(priceStr.c_str(), nullptr));
+    Quantity_t newQty = std::strtoull(qtyStr.c_str(), nullptr, 10);
+
+    oePipe_.push<ModifyOrderEvent>(orderId, origClOrdId, symIdx, newPrice, newQty, sess.sessionId);
+}
+
+// ── Send FIX message ─────────────────────────────────────────────
+
+void FIXGatewayActor::sendFIX(FIXSession& sess, const std::string& msgType,
+                               const std::vector<std::pair<int, std::string>>& fields) {
+    std::ostringstream body;
+    body << "35=" << msgType << '\x01';
+    body << "49=EUNEX" << '\x01';
+    body << "56=" << sess.senderCompId << '\x01';
+    body << "34=" << sess.msgSeqNum++ << '\x01';
+
+    auto now = std::chrono::system_clock::now();
+    auto t = std::chrono::system_clock::to_time_t(now);
+    struct tm tmBuf;
+#ifdef _WIN32
+    gmtime_s(&tmBuf, &t);
+#else
+    gmtime_r(&t, &tmBuf);
+#endif
+    char timeBuf[32];
+    std::strftime(timeBuf, sizeof(timeBuf), "%Y%m%d-%H:%M:%S", &tmBuf);
+    body << "52=" << timeBuf << '\x01';
+
+    for (auto& [tag, val] : fields) {
+        body << tag << "=" << val << '\x01';
+    }
+
+    std::string bodyStr = body.str();
+
+    std::ostringstream msg;
+    msg << "8=FIX.4.4" << '\x01';
+    msg << "9=" << bodyStr.size() << '\x01';
+    msg << bodyStr;
+
+    std::string raw = msg.str();
+    int checksum = 0;
+    for (char c : raw) checksum += static_cast<unsigned char>(c);
+    checksum %= 256;
+
+    char csStr[8];
+    std::snprintf(csStr, sizeof(csStr), "%03d", checksum);
+    raw += "10=";
+    raw += csStr;
+    raw += '\x01';
+
+    send(sess.sock, raw.c_str(), static_cast<int>(raw.size()), 0);
+}
+
+// ── Exec report handling ─────────────────────────────────────────
+
+void FIXGatewayActor::onEvent(const ExecReportEvent& event) {
+    sendExecReport(event.sessionId, event);
+}
+
+void FIXGatewayActor::sendExecReport(SessionId_t sessionId, const ExecReportEvent& rpt) {
+    std::lock_guard<std::mutex> lock(sessionMutex_);
+    auto it = sessions_.find(sessionId);
+    if (it == sessions_.end()) return;
+    FIXSession& sess = *it->second;
+    if (!sess.loggedOn) return;
+
+    auto statusToOrdStatus = [](OrderStatus s) -> std::string {
+        switch (s) {
+            case OrderStatus::New:             return "0";
+            case OrderStatus::PartiallyFilled: return "1";
+            case OrderStatus::Filled:          return "2";
+            case OrderStatus::Cancelled:       return "4";
+            case OrderStatus::Rejected:        return "8";
+            default: return "0";
+        }
+    };
+
+    auto statusToExecType = [](OrderStatus s) -> std::string {
+        switch (s) {
+            case OrderStatus::New:             return "0";
+            case OrderStatus::PartiallyFilled: return "F";
+            case OrderStatus::Filled:          return "F";
+            case OrderStatus::Cancelled:       return "4";
+            case OrderStatus::Rejected:        return "8";
+            default: return "0";
+        }
+    };
+
+    std::vector<std::pair<int, std::string>> fields = {
+        {37, std::to_string(rpt.orderId)},
+        {11, std::to_string(rpt.clOrdId)},
+        {17, std::to_string(rpt.tradeId)},
+        {150, statusToExecType(rpt.status)},
+        {39, statusToOrdStatus(rpt.status)},
+        {14, std::to_string(rpt.filledQty)},
+        {151, std::to_string(rpt.remainingQty)},
+    };
+
+    if (rpt.lastQty > 0) {
+        fields.push_back({31, std::to_string(toDouble(rpt.lastPrice))});
+        fields.push_back({32, std::to_string(rpt.lastQty)});
+    }
+
+    sendFIX(sess, "8", fields);
+}
+
+// ── Symbol mapping ───────────────────────────────────────────────
+
+SymbolIndex_t FIXGatewayActor::symbolFromString(const std::string& sym) {
+    if (sym == "AAPL")   return 1;
+    if (sym == "MSFT")   return 2;
+    if (sym == "GOOGL")  return 3;
+    if (sym == "EURO50") return 4;
+    return static_cast<SymbolIndex_t>(std::strtoul(sym.c_str(), nullptr, 10));
+}
+
+std::string FIXGatewayActor::symbolToString(SymbolIndex_t idx) {
+    switch (idx) {
+        case 1: return "AAPL";
+        case 2: return "MSFT";
+        case 3: return "GOOGL";
+        case 4: return "EURO50";
+        default: return std::to_string(idx);
+    }
+}
+
+} // namespace eunex

src/actors/FIXGatewayActor.hpp

@@ -0,0 +1,91 @@
+#pragma once
+// ════════════════════════════════════════════════════════════════════
+// FIXGatewayActor — C++ FIX 4.4 TCP acceptor
+//
+// Optiq equivalent: OEG FIX Gateway (FIX 4.4 acceptor for OE frontal)
+//
+// Runs a TCP accept loop on a background thread. Each connected client
+// gets a recv thread that parses FIX messages and enqueues them to the
+// actor's mailbox. The actor thread pushes NewOrderEvent / CancelEvent
+// to OEGateway via Event::Pipe.
+//
+// Supported messages:
+//   Logon (35=A), Logout (35=5), Heartbeat (35=0),
+//   NewOrderSingle (35=D), OrderCancelRequest (35=F),
+//   OrderCancelReplaceRequest (35=G)
+//
+// Outbound:
+//   ExecutionReport (35=8) via onEvent(ExecReportEvent)
+// ════════════════════════════════════════════════════════════════════
+
+#include "engine/SimplxShim.hpp"
+#include "actors/Events.hpp"
+#include "net/SocketCompat.hpp"
+#include <thread>
+#include <atomic>
+#include <unordered_map>
+#include <mutex>
+#include <string>
+#include <vector>
+#include <functional>
+
+namespace eunex {
+
+struct FIXSession {
+    socket_t    sock;
+    SessionId_t sessionId;
+    std::string senderCompId;
+    int         msgSeqNum;
+    bool        loggedOn;
+    std::thread recvThread;
+};
+
+class FIXGatewayActor : public tredzone::Actor {
+public:
+    struct Service : tredzone::AsyncService {};
+
+    FIXGatewayActor(const tredzone::ActorId& oeGatewayId, uint16_t port = 9001);
+    ~FIXGatewayActor();
+
+    void onEvent(const ExecReportEvent& event);
+
+    void stop();
+    bool isRunning() const { return running_.load(); }
+    int clientCount() const;
+
+private:
+    tredzone::Actor::Event::Pipe oePipe_;
+    uint16_t port_;
+    std::atomic<bool> running_{false};
+    socket_t listenSock_ = INVALID_SOCK;
+    std::thread acceptThread_;
+    SocketInit sockInit_;
+
+    mutable std::mutex sessionMutex_;
+    std::unordered_map<SessionId_t, std::unique_ptr<FIXSession>> sessions_;
+    SessionId_t nextSessionId_ = 100;
+
+    std::unordered_map<SymbolIndex_t, std::string> symbolNames_;
+
+    void acceptLoop();
+    void clientRecvLoop(SessionId_t sessionId);
+
+    using TagMap = std::unordered_map<int, std::string>;
+    static std::vector<TagMap> parseFIXMessages(const std::string& data);
+    static std::string getTag(const TagMap& msg, int tag, const std::string& def = "");
+
+    void handleLogon(FIXSession& sess, const TagMap& msg);
+    void handleNewOrderSingle(FIXSession& sess, const TagMap& msg);
+    void handleCancelRequest(FIXSession& sess, const TagMap& msg);
+    void handleCancelReplaceRequest(FIXSession& sess, const TagMap& msg);
+
+    void sendFIX(FIXSession& sess, const std::string& msgType,
+                 const std::vector<std::pair<int, std::string>>& fields);
+    void sendExecReport(SessionId_t sessionId, const ExecReportEvent& rpt);
+
+public:
+    static SymbolIndex_t symbolFromString(const std::string& sym);
+    static std::string symbolToString(SymbolIndex_t idx);
+};
+
+} // namespace eunex

src/actors/OEGatewayActor.cpp

@@ -3,6 +3,9 @@
 namespace eunex {
 
 OEGatewayActor::OEGatewayActor() {
+    registerEventHandler<NewOrderEvent>(*this);
+    registerEventHandler<CancelOrderEvent>(*this);
+    registerEventHandler<ModifyOrderEvent>(*this);
     registerEventHandler<ExecReportEvent>(*this);
 }
 
@@ -43,8 +46,31 @@ void OEGatewayActor::submitModify(OrderId_t orderId, ClOrdId_t origClOrdId,
     pipe.push<ModifyOrderEvent>(orderId, origClOrdId, symbolIdx, newPrice, newQty, session);
 }
 
+void OEGatewayActor::onEvent(const NewOrderEvent& event) {
+    submitNewOrder(event.clOrdId, event.symbolIdx, event.side, event.ordType,
+                    event.tif, event.price, event.quantity, event.sessionId);
+}
+
+void OEGatewayActor::onEvent(const CancelOrderEvent& event) {
+    submitCancel(event.orderId, event.origClOrdId, event.symbolIdx, event.sessionId);
+}
+
+void OEGatewayActor::onEvent(const ModifyOrderEvent& event) {
+    submitModify(event.orderId, event.origClOrdId, event.symbolIdx,
+                  event.newPrice, event.newQuantity, event.sessionId);
+}
+
+void OEGatewayActor::addExecReportSubscriber(const tredzone::ActorId& subscriberId) {
+    execReportSubscribers_.push_back(subscriberId);
+}
+
 void OEGatewayActor::onEvent(const ExecReportEvent& event) {
     reports_.push_back(event);
+
+    for (auto& subId : execReportSubscribers_) {
+        Event::Pipe pipe(*this, subId);
+        pipe.push<ExecReportEvent>(event);
+    }
 }
 
 } // namespace eunex

src/actors/OEGatewayActor.hpp

@@ -41,15 +41,21 @@ public:
                       SymbolIndex_t symbolIdx, Price_t newPrice,
                       Quantity_t newQty, SessionId_t session);
 
-    // Handle execution reports coming back from OrderBookActor
+    void onEvent(const NewOrderEvent& event);
+    void onEvent(const CancelOrderEvent& event);
+    void onEvent(const ModifyOrderEvent& event);
     void onEvent(const ExecReportEvent& event);
 
+    // Subscribe to execution reports (FIXGateway, AITrader, etc.)
+    void addExecReportSubscriber(const tredzone::ActorId& subscriberId);
+
     // Access received reports (for testing / downstream forwarding)
     const std::vector<ExecReportEvent>& getReports() const { return reports_; }
     void clearReports() { reports_.clear(); }
 
 private:
     std::unordered_map<SymbolIndex_t, tredzone::ActorId> symbolMap_;
+    std::vector<tredzone::ActorId> execReportSubscribers_;
     std::vector<ExecReportEvent> reports_;
     ClOrdId_t nextClOrdId_ = 1000;
 };

src/actors/OrderBookActor.cpp

@@ -5,11 +5,15 @@ namespace eunex {
 
 OrderBookActor::OrderBookActor(SymbolIndex_t symbolIdx,
                                const tredzone::ActorId& oeGatewayId,
-                               const tredzone::ActorId& marketDataId)
+                               const tredzone::ActorId& marketDataId,
+                               const tredzone::ActorId& clearingHouseId)
     : book_(symbolIdx)
     , oePipe_(*this, oeGatewayId)
     , mdPipe_(*this, marketDataId)
 {
+    if (clearingHouseId.id != 0) {
+        chPipe_.emplace(*this, clearingHouseId);
+    }
     registerEventHandler<NewOrderEvent>(*this);
     registerEventHandler<CancelOrderEvent>(*this);
     registerEventHandler<ModifyOrderEvent>(*this);
@@ -37,9 +41,9 @@ void OrderBookActor::onEvent(const NewOrderEvent& event) {
     //   Effect → publish limit update to MDLimit
 
     book_.newOrder(order,
-        // Trade callback — emit trade to MarketData actor
         [this](const Trade& trade) {
             mdPipe_.push<TradeEvent>(trade);
+            if (chPipe_) chPipe_->push<TradeEvent>(trade);
         },
         // Execution report — send back to OE Gateway
         [this, &event](const ExecutionReport& rpt) {

src/actors/OrderBookActor.hpp

@@ -19,6 +19,7 @@
 #include "engine/SimplxShim.hpp"
 #include "common/OrderBook.hpp"
 #include "actors/Events.hpp"
+#include <optional>
 
 namespace eunex {
 
@@ -28,7 +29,8 @@ public:
 
     OrderBookActor(SymbolIndex_t symbolIdx,
                    const tredzone::ActorId& oeGatewayId,
-                   const tredzone::ActorId& marketDataId);
+                   const tredzone::ActorId& marketDataId,
+                   const tredzone::ActorId& clearingHouseId = tredzone::ActorId{});
 
     void onEvent(const NewOrderEvent& event);
     void onEvent(const CancelOrderEvent& event);
@@ -38,6 +40,7 @@ private:
     OrderBook book_;
     tredzone::Actor::Event::Pipe oePipe_;
     tredzone::Actor::Event::Pipe mdPipe_;
+    std::optional<tredzone::Actor::Event::Pipe> chPipe_;
 
     void publishBookUpdate();
 };

src/common/OrderBook.cpp

@@ -100,6 +100,8 @@ void OrderBook::matchBuy(Order& incoming, const TradeCallback& onTrade,
             trade.sellOrderId = orderIt->orderId;
             trade.buyClOrdId  = incoming.clOrdId;
             trade.sellClOrdId = orderIt->clOrdId;
+            trade.buySessionId  = incoming.sessionId;
+            trade.sellSessionId = orderIt->sessionId;
             trade.matchTime   = nowNs();
             onTrade(trade);
 
@@ -155,6 +157,8 @@ void OrderBook::matchSell(Order& incoming, const TradeCallback& onTrade,
             trade.sellOrderId = incoming.orderId;
             trade.buyClOrdId  = orderIt->clOrdId;
             trade.sellClOrdId = incoming.clOrdId;
+            trade.buySessionId  = orderIt->sessionId;
+            trade.sellSessionId = incoming.sessionId;
             trade.matchTime   = nowNs();
             onTrade(trade);
 

src/common/Types.hpp

@@ -29,6 +29,7 @@ using ClOrdId_t     = uint64_t;
 using SymbolIndex_t = uint32_t;
 using TradeId_t     = uint64_t;
 using SessionId_t   = uint16_t;
+using MemberId_t    = uint16_t;
 
 // ── Enumerations matching Optiq/SBE definitions ────────────────────
 enum class Side : uint8_t {
@@ -104,6 +105,8 @@ struct Trade {
     ClOrdId_t     buyClOrdId;
     ClOrdId_t     sellClOrdId;
     Timestamp_ns  matchTime;
+    SessionId_t   buySessionId;
+    SessionId_t   sellSessionId;
 };
 #pragma pack(pop)
 
@@ -119,6 +122,13 @@ struct ExecutionReport {
     TradeId_t    tradeId;
 };
 
+// ── Member holding (for Clearing House) ───────────────────────────
+struct MemberHolding {
+    SymbolIndex_t symbolIdx;
+    int64_t       quantity;
+    Price_t       avgCost;
+};
+
 // ── Symbol definition ──────────────────────────────────────────────
 struct SymbolDef {
     SymbolIndex_t index;

src/main.cpp

@@ -3,135 +3,214 @@
 //
 // Multi-threaded actor topology (mirrors Optiq architecture):
 //
-//   Core 0: OEGatewayActor (Order Entry — receives external orders)
+//   Core 0: OEGatewayActor + FIXGatewayActor
 //   Core 1: OrderBookActor per symbol (matching engine)
-//   Core 2: MarketDataActor (publishes book updates, trades)
+//   Core 2: MarketDataActor
+//   Core 3: ClearingHouseActor + AITraderActor
 //
 // Optiq equivalent topology:
 //   OEActor → LogicalCoreActor (Book) → MDLimit → MDIMP
 //                                     → OE Ack (back to OEActor)
+//                                     → ClearingHouse (via Kafka/PTB)
 // ════════════════════════════════════════════════════════════════════
 
 #include "engine/SimplxShim.hpp"
 #include "actors/OrderBookActor.hpp"
 #include "actors/OEGatewayActor.hpp"
 #include "actors/MarketDataActor.hpp"
+#include "actors/ClearingHouseActor.hpp"
+#include "actors/FIXGatewayActor.hpp"
+#include "actors/AITraderActor.hpp"
 #include <iostream>
+#include <thread>
+#include <chrono>
+#include <csignal>
+#include <atomic>
 
 using namespace tredzone;
 using namespace eunex;
 
+static std::atomic<bool> g_running{true};
+
+void signalHandler(int) { g_running = false; }
+
 int main() {
     std::cout << "═══════════════════════════════════════════\n";
-    std::cout << "  EuNEx Matching Engine v0.2\n";
-    std::cout << "  Multi-threaded actor engine\n";
+    std::cout << "  EuNEx Matching Engine v0.4\n";
+    std::cout << "  C++ Actor Architecture (Optiq model)\n";
     std::cout << "═══════════════════════════════════════════\n\n";
 
-    // ── Build actor topology ───────────────────────────────────────
+    std::signal(SIGINT, signalHandler);
+    std::signal(SIGTERM, signalHandler);
+
+    // ── Symbol definitions ────────────────────────────────────────
+    constexpr SymbolIndex_t SYM_AAPL  = 1;
+    constexpr SymbolIndex_t SYM_MSFT  = 2;
+    constexpr SymbolIndex_t SYM_GOOGL = 3;
+    constexpr SymbolIndex_t SYM_EURO50 = 4;
+
+    std::vector<SymbolIndex_t> allSymbols = {SYM_AAPL, SYM_MSFT, SYM_GOOGL, SYM_EURO50};
+
+    // ── Core 0: OE Gateway ────────────────────────────────────────
     auto oeGateway = std::make_unique<OEGatewayActor>();
-    auto mdActor   = std::make_unique<MarketDataActor>();
 
-    constexpr SymbolIndex_t SYM_AAPL = 1;
-    constexpr SymbolIndex_t SYM_MSFT = 2;
+    // ── Core 2: Market Data ───────────────────────────────────────
+    auto mdActor = std::make_unique<MarketDataActor>();
+
+    // ── Core 3: Clearing House ────────────────────────────────────
+    auto chActor = std::make_unique<ClearingHouseActor>();
+
+    // Map AI trader sessions to clearing house members
+    for (int i = 0; i < 10; ++i) {
+        chActor->mapSession(static_cast<SessionId_t>(200 + i),
+                            static_cast<MemberId_t>(i + 1));
+    }
+    // Map FIX gateway sessions (100-109) to members too
+    for (int i = 0; i < 10; ++i) {
+        chActor->mapSession(static_cast<SessionId_t>(100 + i),
+                            static_cast<MemberId_t>(i + 1));
+    }
 
+    // ── Core 1: Order Books (per symbol) ──────────────────────────
     auto bookAAPL = std::make_unique<OrderBookActor>(
-        SYM_AAPL, oeGateway->getActorId(), mdActor->getActorId());
+        SYM_AAPL, oeGateway->getActorId(), mdActor->getActorId(), chActor->getActorId());
     auto bookMSFT = std::make_unique<OrderBookActor>(
-        SYM_MSFT, oeGateway->getActorId(), mdActor->getActorId());
+        SYM_MSFT, oeGateway->getActorId(), mdActor->getActorId(), chActor->getActorId());
+    auto bookGOOGL = std::make_unique<OrderBookActor>(
+        SYM_GOOGL, oeGateway->getActorId(), mdActor->getActorId(), chActor->getActorId());
+    auto bookEURO50 = std::make_unique<OrderBookActor>(
+        SYM_EURO50, oeGateway->getActorId(), mdActor->getActorId(), chActor->getActorId());
 
     oeGateway->mapSymbol(SYM_AAPL, bookAAPL->getActorId());
     oeGateway->mapSymbol(SYM_MSFT, bookMSFT->getActorId());
-
-    std::cout << "Actors created:\n";
-    std::cout << "  OEGateway  (id=" << oeGateway->getActorId().id << ")\n";
-    std::cout << "  MarketData (id=" << mdActor->getActorId().id << ")\n";
-    std::cout << "  Book AAPL  (id=" << bookAAPL->getActorId().id << ")\n";
-    std::cout << "  Book MSFT  (id=" << bookMSFT->getActorId().id << ")\n\n";
-
-    // ── Submit orders ──────────────────────────────────────────────
-    SessionId_t session = 1;
-    std::cout << "── Submitting orders ──────────────────────\n\n";
-
-    oeGateway->submitNewOrder(1001, SYM_AAPL, Side::Sell, OrderType::Limit,
-                               TimeInForce::Day, toFixedPrice(150.00), 100, session);
-    std::cout << "SELL AAPL 100 @ 150.00\n";
-
-    oeGateway->submitNewOrder(1002, SYM_AAPL, Side::Sell, OrderType::Limit,
-                               TimeInForce::Day, toFixedPrice(151.00), 50, session);
-    std::cout << "SELL AAPL  50 @ 151.00\n";
-
-    oeGateway->submitNewOrder(1003, SYM_AAPL, Side::Buy, OrderType::Limit,
-                               TimeInForce::Day, toFixedPrice(150.00), 75, session);
-    std::cout << "BUY  AAPL  75 @ 150.00 (should match 75 of sell@150)\n";
-
-    oeGateway->submitNewOrder(1004, SYM_AAPL, Side::Buy, OrderType::Market,
-                               TimeInForce::IOC, NULL_PRICE, 30, session);
-    std::cout << "BUY  AAPL  30 MARKET IOC (should match 25@150 + 5@151)\n";
-
-    oeGateway->submitNewOrder(1005, SYM_AAPL, Side::Buy, OrderType::Limit,
-                               TimeInForce::FOK, toFixedPrice(151.00), 100, session);
-    std::cout << "BUY  AAPL 100 @ 151.00 FOK (should be rejected)\n";
-
-    oeGateway->submitNewOrder(2001, SYM_MSFT, Side::Buy, OrderType::Limit,
-                               TimeInForce::Day, toFixedPrice(320.50), 200, session);
-    std::cout << "BUY  MSFT 200 @ 320.50\n";
-
-    oeGateway->submitNewOrder(2002, SYM_MSFT, Side::Sell, OrderType::Limit,
-                               TimeInForce::Day, toFixedPrice(320.50), 150, session);
-    std::cout << "SELL MSFT 150 @ 320.50 (should match 150)\n";
-
-    // ── Print results ──────────────────────────────────────────────
-    std::cout << "\n── Execution Reports ─────────────────────\n\n";
-
-    auto statusStr = [](OrderStatus s) -> const char* {
-        switch (s) {
-            case OrderStatus::New: return "NEW";
-            case OrderStatus::PartiallyFilled: return "PARTIAL";
-            case OrderStatus::Filled: return "FILLED";
-            case OrderStatus::Cancelled: return "CANCELLED";
-            case OrderStatus::Rejected: return "REJECTED";
-            default: return "UNKNOWN";
-        }
+    oeGateway->mapSymbol(SYM_GOOGL, bookGOOGL->getActorId());
+    oeGateway->mapSymbol(SYM_EURO50, bookEURO50->getActorId());
+
+    // ── Core 0: FIX Gateway ──────────────────────────────────────
+    auto fixGateway = std::make_unique<FIXGatewayActor>(oeGateway->getActorId(), 9001);
+
+    // ── Core 3: AI Trader ─────────────────────────────────────────
+    auto aiTrader = std::make_unique<AITraderActor>(oeGateway->getActorId(), allSymbols);
+
+    // ── Wire exec report subscribers ──────────────────────────────
+    oeGateway->addExecReportSubscriber(fixGateway->getActorId());
+    oeGateway->addExecReportSubscriber(aiTrader->getActorId());
+
+    // ── Print topology ────────────────────────────────────────────
+    std::cout << "Actor topology:\n";
+    std::cout << "  Core 0: OEGateway (id=" << oeGateway->getActorId().id
+              << "), FIXGateway (id=" << fixGateway->getActorId().id << ")\n";
+    std::cout << "  Core 1: Book AAPL (id=" << bookAAPL->getActorId().id
+              << "), MSFT (id=" << bookMSFT->getActorId().id
+              << "), GOOGL (id=" << bookGOOGL->getActorId().id
+              << "), EURO50 (id=" << bookEURO50->getActorId().id << ")\n";
+    std::cout << "  Core 2: MarketData (id=" << mdActor->getActorId().id << ")\n";
+    std::cout << "  Core 3: ClearingHouse (id=" << chActor->getActorId().id
+              << "), AITrader (id=" << aiTrader->getActorId().id << ")\n\n";
+
+    std::cout << "Services:\n";
+    std::cout << "  FIX Gateway:  TCP port 9001\n";
+    std::cout << "  AI Traders:   10 members (MBR01-MBR10)\n";
+    std::cout << "  Symbols:      AAPL, MSFT, GOOGL, EURO50\n\n";
+
+    // ── Seed initial orders for AI to have market data ────────────
+    std::cout << "Seeding initial order book...\n";
+    SessionId_t seedSession = 200;
+
+    struct SeedOrder { SymbolIndex_t sym; Side side; double price; Quantity_t qty; };
+    SeedOrder seeds[] = {
+        {SYM_AAPL,  Side::Sell, 155.00, 100}, {SYM_AAPL,  Side::Sell, 154.00, 200},
+        {SYM_AAPL,  Side::Buy,  153.00, 150}, {SYM_AAPL,  Side::Buy,  152.00, 100},
+        {SYM_MSFT,  Side::Sell, 325.00, 100}, {SYM_MSFT,  Side::Sell, 324.00, 150},
+        {SYM_MSFT,  Side::Buy,  323.00, 200}, {SYM_MSFT,  Side::Buy,  322.00, 100},
+        {SYM_GOOGL, Side::Sell, 142.00, 100}, {SYM_GOOGL, Side::Sell, 141.00, 200},
+        {SYM_GOOGL, Side::Buy,  140.00, 150}, {SYM_GOOGL, Side::Buy,  139.00, 100},
+        {SYM_EURO50, Side::Sell, 5050.00, 50}, {SYM_EURO50, Side::Sell, 5040.00, 80},
+        {SYM_EURO50, Side::Buy,  5030.00, 60}, {SYM_EURO50, Side::Buy,  5020.00, 40},
     };
 
-    for (auto& rpt : oeGateway->getReports()) {
-        std::cout << "  ClOrdId=" << rpt.clOrdId
-                  << " OrderId=" << rpt.orderId
-                  << " Status=" << statusStr(rpt.status)
-                  << " Filled=" << rpt.filledQty
-                  << " Remaining=" << rpt.remainingQty;
-        if (rpt.lastQty > 0) {
-            std::cout << " LastPx=" << toDouble(rpt.lastPrice)
-                      << " LastQty=" << rpt.lastQty;
+    ClOrdId_t seedClOrd = 1;
+    for (auto& s : seeds) {
+        oeGateway->submitNewOrder(seedClOrd++, s.sym, s.side, OrderType::Limit,
+                                   TimeInForce::Day, toFixedPrice(s.price), s.qty, seedSession);
+    }
+    oeGateway->clearReports();
+
+    std::cout << "Initial orders seeded.\n\n";
+
+    // ── Run AI trading rounds ─────────────────────────────────────
+    std::cout << "Running AI trading... (Ctrl+C to stop)\n";
+    std::cout << "FIX clients can connect to localhost:9001\n\n";
+
+    int round = 0;
+    while (g_running) {
+        aiTrader->onCallback();
+        round++;
+
+        if (round % 10 == 0) {
+            std::cout << "── Round " << round << " ──\n";
+
+            auto leaderboard = chActor->getLeaderboard();
+            std::cout << "  Leaderboard:\n";
+            for (int i = 0; i < std::min(5, static_cast<int>(leaderboard.size())); ++i) {
+                auto& e = leaderboard[i];
+                std::cout << "    " << e.name
+                          << "  Capital=" << static_cast<int>(e.capital)
+                          << "  P&L=" << static_cast<int>(e.pnl)
+                          << "  Trades=" << e.tradeCount << "\n";
+            }
+
+            auto printBBO = [&](SymbolIndex_t sym, const char* name) {
+                auto* snap = mdActor->getSnapshot(sym);
+                if (snap) {
+                    std::cout << "  " << name << ":"
+                              << " Bid=" << toDouble(snap->bestBid)
+                              << " Ask=" << toDouble(snap->bestAsk)
+                              << " Last=" << toDouble(snap->lastTradePrice)
+                              << " Trades=" << snap->tradeCount << "\n";
+                }
+            };
+
+            printBBO(SYM_AAPL, "AAPL");
+            printBBO(SYM_MSFT, "MSFT");
+            printBBO(SYM_GOOGL, "GOOGL");
+            printBBO(SYM_EURO50, "EURO50");
+
+            if (fixGateway->isRunning()) {
+                std::cout << "  FIX clients: " << fixGateway->clientCount() << "\n";
+            }
+            std::cout << "\n";
         }
-        std::cout << "\n";
+
+        std::this_thread::sleep_for(std::chrono::seconds(3));
     }
 
-    // ── Print market data ──────────────────────────────────────────
-    std::cout << "\n── Market Data ───────────────────────────\n\n";
+    // ── Shutdown ──────────────────────────────────────────────────
+    std::cout << "\nShutting down...\n";
+    fixGateway->stop();
 
-    auto printSnapshot = [&](SymbolIndex_t sym, const char* name) {
+    std::cout << "\n── Final Market Data ─────────────────────\n";
+    for (auto sym : allSymbols) {
         auto* snap = mdActor->getSnapshot(sym);
         if (snap) {
-            std::cout << "  " << name << ":"
-                      << " LastPx=" << toDouble(snap->lastTradePrice)
-                      << " BestBid=" << toDouble(snap->bestBid)
-                      << " BestAsk=" << toDouble(snap->bestAsk)
-                      << " Trades=" << snap->tradeCount << "\n";
+            const char* names[] = {"", "AAPL", "MSFT", "GOOGL", "EURO50"};
+            std::cout << "  " << names[sym] << ": "
+                      << snap->tradeCount << " trades, last=" << toDouble(snap->lastTradePrice) << "\n";
         }
-    };
-
-    printSnapshot(SYM_AAPL, "AAPL");
-    printSnapshot(SYM_MSFT, "MSFT");
+    }
 
-    std::cout << "\n  Recent trades: " << mdActor->getRecentTrades().size() << "\n";
-    for (auto& t : mdActor->getRecentTrades()) {
-        const char* sym = (t.symbolIdx == SYM_AAPL) ? "AAPL" : "MSFT";
-        std::cout << "    " << sym << " " << t.quantity << " @ " << toDouble(t.price)
-                  << " (buy=" << t.buyOrderId << " sell=" << t.sellOrderId << ")\n";
+    std::cout << "\n── Final Leaderboard ─────────────────────\n";
+    auto lb = chActor->getLeaderboard();
+    for (auto& e : lb) {
+        std::cout << "  " << e.name
+                  << "  Capital=" << static_cast<int>(e.capital)
+                  << "  P&L=" << static_cast<int>(e.pnl)
+                  << "  Trades=" << e.tradeCount
+                  << "  Holdings=" << e.holdingCount << "\n";
     }
 
-    std::cout << "\n═══════════════════════════════════════════\n";
+    std::cout << "\nTrades processed: " << mdActor->getRecentTrades().size() << "\n";
+    std::cout << "═══════════════════════════════════════════\n";
     std::cout << "  Engine stopped.\n";
     return 0;
 }

src/net/SocketCompat.hpp

@@ -0,0 +1,61 @@
+#pragma once
+// Cross-platform socket abstraction for FIXGatewayActor
+
+#ifdef _WIN32
+  #ifndef WIN32_LEAN_AND_MEAN
+    #define WIN32_LEAN_AND_MEAN
+  #endif
+  #ifndef NOMINMAX
+    #define NOMINMAX
+  #endif
+  #include <winsock2.h>
+  #include <ws2tcpip.h>
+
+  using socket_t = SOCKET;
+  constexpr socket_t INVALID_SOCK = INVALID_SOCKET;
+
+  inline int closeSocket(socket_t s) { return closesocket(s); }
+  inline int socketError() { return WSAGetLastError(); }
+
+  struct SocketInit {
+      SocketInit() { WSADATA w; WSAStartup(MAKEWORD(2,2), &w); }
+      ~SocketInit() { WSACleanup(); }
+  };
+
+#else
+  #include <sys/socket.h>
+  #include <netinet/in.h>
+  #include <netinet/tcp.h>
+  #include <arpa/inet.h>
+  #include <unistd.h>
+  #include <cerrno>
+  #include <fcntl.h>
+
+  using socket_t = int;
+  constexpr socket_t INVALID_SOCK = -1;
+
+  inline int closeSocket(socket_t s) { return close(s); }
+  inline int socketError() { return errno; }
+
+  struct SocketInit {
+      SocketInit() {}
+      ~SocketInit() {}
+  };
+
+#endif
+
+inline bool setSocketNonBlocking(socket_t s) {
+#ifdef _WIN32
+    u_long mode = 1;
+    return ioctlsocket(s, FIONBIO, &mode) == 0;
+#else
+    int flags = fcntl(s, F_GETFL, 0);
+    return fcntl(s, F_SETFL, flags | O_NONBLOCK) == 0;
+#endif
+}
+
+inline bool setSocketReuseAddr(socket_t s) {
+    int opt = 1;
+    return setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
+                      reinterpret_cast<const char*>(&opt), sizeof(opt)) == 0;
+}

tests/test_ai_trader.cpp

@@ -0,0 +1,157 @@
+// ════════════════════════════════════════════════════════════════════
+// AITraderActor tests — strategy execution and order submission
+// ════════════════════════════════════════════════════════════════════
+
+#include "actors/AITraderActor.hpp"
+#include "actors/OEGatewayActor.hpp"
+#include "actors/OrderBookActor.hpp"
+#include "actors/MarketDataActor.hpp"
+#include "actors/ClearingHouseActor.hpp"
+#include <iostream>
+#include <cassert>
+
+using namespace eunex;
+
+static int testsPassed = 0;
+static int testsFailed = 0;
+
+#define TEST(name) \
+    std::cout << "  " << #name << "... "; \
+    try { test_##name(); std::cout << "PASS\n"; ++testsPassed; } \
+    catch (const std::exception& e) { std::cout << "FAIL: " << e.what() << "\n"; ++testsFailed; }
+
+#define ASSERT_EQ(a, b) \
+    if ((a) != (b)) throw std::runtime_error( \
+        std::string("Expected ") + std::to_string(static_cast<long long>(b)) + " got " + std::to_string(static_cast<long long>(a)))
+
+#define ASSERT_TRUE(x) \
+    if (!(x)) throw std::runtime_error("Assertion failed: " #x)
+
+// ── Tests ─────────────────────────────────────────────────────────
+
+void test_ai_trader_creates() {
+    auto oe = std::make_unique<OEGatewayActor>();
+    std::vector<SymbolIndex_t> syms = {1, 2};
+    auto ai = std::make_unique<AITraderActor>(oe->getActorId(), syms);
+    ASSERT_TRUE(ai != nullptr);
+}
+
+void test_ai_submits_orders() {
+    auto oe = std::make_unique<OEGatewayActor>();
+    auto md = std::make_unique<MarketDataActor>();
+
+    auto book1 = std::make_unique<OrderBookActor>(1, oe->getActorId(), md->getActorId());
+    auto book2 = std::make_unique<OrderBookActor>(2, oe->getActorId(), md->getActorId());
+    oe->mapSymbol(1, book1->getActorId());
+    oe->mapSymbol(2, book2->getActorId());
+
+    std::vector<SymbolIndex_t> syms = {1, 2};
+    auto ai = std::make_unique<AITraderActor>(oe->getActorId(), syms);
+
+    ai->onCallback();
+
+    ASSERT_TRUE(oe->getReports().size() > 0);
+}
+
+void test_ai_responds_to_book_update() {
+    auto oe = std::make_unique<OEGatewayActor>();
+    auto md = std::make_unique<MarketDataActor>();
+    auto book = std::make_unique<OrderBookActor>(1, oe->getActorId(), md->getActorId());
+    oe->mapSymbol(1, book->getActorId());
+
+    std::vector<SymbolIndex_t> syms = {1};
+    auto ai = std::make_unique<AITraderActor>(oe->getActorId(), syms);
+
+    BookUpdateEvent bue;
+    bue.symbolIdx = 1;
+    bue.bidDepth = 1;
+    bue.askDepth = 1;
+    bue.bids[0] = {toFixedPrice(150.0), 100};
+    bue.asks[0] = {toFixedPrice(151.0), 100};
+    ai->onEvent(bue);
+
+    ai->onCallback();
+
+    ASSERT_TRUE(oe->getReports().size() > 0);
+}
+
+void test_ai_responds_to_trade() {
+    auto oe = std::make_unique<OEGatewayActor>();
+    std::vector<SymbolIndex_t> syms = {1};
+    auto ai = std::make_unique<AITraderActor>(oe->getActorId(), syms);
+
+    Trade t{};
+    t.symbolIdx = 1;
+    t.price = toFixedPrice(150.0);
+    t.quantity = 10;
+    TradeEvent evt(t);
+
+    for (int i = 0; i < 10; ++i) {
+        t.price = toFixedPrice(150.0 + i * 0.5);
+        TradeEvent e(t);
+        ai->onEvent(e);
+    }
+
+    ASSERT_TRUE(true);
+}
+
+void test_ai_with_clearing_house() {
+    auto oe = std::make_unique<OEGatewayActor>();
+    auto md = std::make_unique<MarketDataActor>();
+    auto ch = std::make_unique<ClearingHouseActor>();
+
+    for (int i = 0; i < 10; ++i) {
+        ch->mapSession(static_cast<SessionId_t>(200 + i),
+                       static_cast<MemberId_t>(i + 1));
+    }
+
+    auto book = std::make_unique<OrderBookActor>(
+        1, oe->getActorId(), md->getActorId(), ch->getActorId());
+    oe->mapSymbol(1, book->getActorId());
+
+    std::vector<SymbolIndex_t> syms = {1};
+    auto ai = std::make_unique<AITraderActor>(oe->getActorId(), syms);
+
+    for (int i = 0; i < 5; ++i) {
+        ai->onCallback();
+    }
+
+    auto lb = ch->getLeaderboard();
+    ASSERT_EQ(static_cast<int>(lb.size()), 10);
+}
+
+void test_multiple_symbols() {
+    auto oe = std::make_unique<OEGatewayActor>();
+    auto md = std::make_unique<MarketDataActor>();
+
+    std::vector<SymbolIndex_t> syms = {1, 2, 3, 4};
+    std::vector<std::unique_ptr<OrderBookActor>> books;
+    for (auto s : syms) {
+        auto book = std::make_unique<OrderBookActor>(s, oe->getActorId(), md->getActorId());
+        oe->mapSymbol(s, book->getActorId());
+        books.push_back(std::move(book));
+    }
+
+    auto ai = std::make_unique<AITraderActor>(oe->getActorId(), syms);
+    ai->onCallback();
+
+    ASSERT_TRUE(oe->getReports().size() > 0);
+}
+
+// ── Main ────────────────────────────���─────────────────────────────
+
+int main() {
+    std::cout << "AITrader Tests\n";
+    std::cout << "═══════════════════════════════════════════\n";
+
+    TEST(ai_trader_creates);
+    TEST(ai_submits_orders);
+    TEST(ai_responds_to_book_update);
+    TEST(ai_responds_to_trade);
+    TEST(ai_with_clearing_house);
+    TEST(multiple_symbols);
+
+    std::cout << "═══════════════════════════════════════════\n";
+    std::cout << testsPassed << " passed, " << testsFailed << " failed\n";
+    return testsFailed > 0 ? 1 : 0;
+}

tests/test_clearing_house.cpp

@@ -0,0 +1,184 @@
+// ════════════════════════════════════════════════════════════════════
+// ClearingHouseActor tests
+// ════════════════════════════════════════════════════════════════════
+
+#include "actors/ClearingHouseActor.hpp"
+#include "actors/OrderBookActor.hpp"
+#include "actors/OEGatewayActor.hpp"
+#include "actors/MarketDataActor.hpp"
+#include <iostream>
+#include <cassert>
+
+using namespace eunex;
+
+static int testsPassed = 0;
+static int testsFailed = 0;
+
+#define TEST(name) \
+    std::cout << "  " << #name << "... "; \
+    try { test_##name(); std::cout << "PASS\n"; ++testsPassed; } \
+    catch (const std::exception& e) { std::cout << "FAIL: " << e.what() << "\n"; ++testsFailed; }
+
+#define ASSERT_EQ(a, b) \
+    if ((a) != (b)) throw std::runtime_error( \
+        std::string("Expected ") + std::to_string(static_cast<long long>(b)) + " got " + std::to_string(static_cast<long long>(a)))
+
+#define ASSERT_TRUE(x) \
+    if (!(x)) throw std::runtime_error("Assertion failed: " #x)
+
+// ── Tests ─────────────────────────────────────────────────────────
+
+void test_initial_members() {
+    ClearingHouseActor ch;
+    auto lb = ch.getLeaderboard();
+    ASSERT_EQ(static_cast<int>(lb.size()), 10);
+    for (auto& e : lb) {
+        ASSERT_EQ(static_cast<int>(e.capital), 100000);
+        ASSERT_EQ(static_cast<int>(e.pnl), 0);
+        ASSERT_EQ(e.tradeCount, 0);
+    }
+}
+
+void test_session_mapping() {
+    ClearingHouseActor ch;
+    ch.mapSession(100, 1);
+    ch.mapSession(101, 2);
+
+    Trade t{};
+    t.symbolIdx = 1;
+    t.price = toFixedPrice(150.0);
+    t.quantity = 10;
+    t.buySessionId = 100;
+    t.sellSessionId = 101;
+
+    TradeEvent evt(t);
+    ch.onEvent(evt);
+
+    auto lb = ch.getLeaderboard();
+    int totalTrades = 0;
+    for (auto& e : lb) totalTrades += e.tradeCount;
+    ASSERT_EQ(totalTrades, 2);
+}
+
+void test_buy_reduces_capital() {
+    ClearingHouseActor ch;
+    ch.mapSession(100, 1);
+
+    Trade t{};
+    t.symbolIdx = 1;
+    t.price = toFixedPrice(100.0);
+    t.quantity = 10;
+    t.buySessionId = 100;
+    t.sellSessionId = 999;
+
+    TradeEvent evt(t);
+    ch.onEvent(evt);
+
+    auto* m = ch.getMember(1);
+    ASSERT_TRUE(m != nullptr);
+    ASSERT_TRUE(m->capital < 100000.0);
+    ASSERT_EQ(static_cast<int>(m->capital), 99000);
+}
+
+void test_sell_increases_capital() {
+    ClearingHouseActor ch;
+    ch.mapSession(100, 1);
+
+    Trade t{};
+    t.symbolIdx = 1;
+    t.price = toFixedPrice(100.0);
+    t.quantity = 10;
+    t.buySessionId = 999;
+    t.sellSessionId = 100;
+
+    TradeEvent evt(t);
+    ch.onEvent(evt);
+
+    auto* m = ch.getMember(1);
+    ASSERT_TRUE(m != nullptr);
+    ASSERT_TRUE(m->capital > 100000.0);
+    ASSERT_EQ(static_cast<int>(m->capital), 101000);
+}
+
+void test_holdings_tracked() {
+    ClearingHouseActor ch;
+    ch.mapSession(100, 1);
+
+    Trade t{};
+    t.symbolIdx = 1;
+    t.price = toFixedPrice(150.0);
+    t.quantity = 10;
+    t.buySessionId = 100;
+    t.sellSessionId = 999;
+
+    TradeEvent evt(t);
+    ch.onEvent(evt);
+
+    auto* m = ch.getMember(1);
+    ASSERT_TRUE(m != nullptr);
+    ASSERT_EQ(static_cast<int>(m->holdings.size()), 1);
+    auto hIt = m->holdings.find(1);
+    ASSERT_TRUE(hIt != m->holdings.end());
+    ASSERT_EQ(hIt->second.quantity, 10);
+}
+
+void test_leaderboard_sorted() {
+    ClearingHouseActor ch;
+    ch.mapSession(100, 1);
+    ch.mapSession(101, 2);
+
+    Trade t1{};
+    t1.symbolIdx = 1;
+    t1.price = toFixedPrice(100.0);
+    t1.quantity = 50;
+    t1.buySessionId = 100;
+    t1.sellSessionId = 101;
+
+    TradeEvent evt1(t1);
+    ch.onEvent(evt1);
+
+    auto lb = ch.getLeaderboard();
+    ASSERT_TRUE(lb[0].capital >= lb[1].capital);
+}
+
+void test_trade_with_clearing_pipe() {
+    auto oe = std::make_unique<OEGatewayActor>();
+    auto md = std::make_unique<MarketDataActor>();
+    auto ch = std::make_unique<ClearingHouseActor>();
+
+    ch->mapSession(1, 1);
+    ch->mapSession(2, 2);
+
+    auto book = std::make_unique<OrderBookActor>(
+        1, oe->getActorId(), md->getActorId(), ch->getActorId());
+    oe->mapSymbol(1, book->getActorId());
+
+    oe->submitNewOrder(1, 1, Side::Sell, OrderType::Limit,
+                        TimeInForce::Day, toFixedPrice(100.0), 50, 1);
+    oe->submitNewOrder(2, 1, Side::Buy, OrderType::Limit,
+                        TimeInForce::Day, toFixedPrice(100.0), 50, 2);
+
+    auto lb = ch->getLeaderboard();
+    int totalTrades = 0;
+    for (auto& e : lb) totalTrades += e.tradeCount;
+    ASSERT_TRUE(totalTrades >= 2);
+}
+
+// ── Main ───────────────────────────────────���──────────────────────
+
+int main() {
+    std::cout << "ClearingHouse Tests\n";
+    std::cout << "═══════════════════════════════════════════\n";
+
+    TEST(initial_members);
+    TEST(session_mapping);
+    TEST(buy_reduces_capital);
+    TEST(sell_increases_capital);
+    TEST(holdings_tracked);
+    TEST(leaderboard_sorted);
+    TEST(trade_with_clearing_pipe);
+
+    std::cout << "═══════════════════════════════════════════\n";
+    std::cout << testsPassed << " passed, " << testsFailed << " failed\n";
+    return testsFailed > 0 ? 1 : 0;
+}

tests/test_fix_gateway.cpp

@@ -0,0 +1,102 @@
+// ════════════════════════════════════════════════════════════════════
+// FIXGatewayActor tests — protocol parsing and symbol mapping
+// ════════════════════════════════════════════════════════════════════
+
+#include "actors/FIXGatewayActor.hpp"
+#include "actors/OEGatewayActor.hpp"
+#include "actors/OrderBookActor.hpp"
+#include "actors/MarketDataActor.hpp"
+#include <iostream>
+#include <cassert>
+#include <string>
+
+using namespace eunex;
+
+static int testsPassed = 0;
+static int testsFailed = 0;
+
+#define TEST(name) \
+    std::cout << "  " << #name << "... "; \
+    try { test_##name(); std::cout << "PASS\n"; ++testsPassed; } \
+    catch (const std::exception& e) { std::cout << "FAIL: " << e.what() << "\n"; ++testsFailed; }
+
+#define ASSERT_EQ(a, b) \
+    if ((a) != (b)) throw std::runtime_error( \
+        std::string("Expected ") + std::to_string(static_cast<long long>(b)) + " got " + std::to_string(static_cast<long long>(a)))
+
+#define ASSERT_TRUE(x) \
+    if (!(x)) throw std::runtime_error("Assertion failed: " #x)
+
+// ── Tests ─────────────────────────────────────────────────────────
+
+void test_symbol_from_string() {
+    ASSERT_EQ(FIXGatewayActor::symbolFromString("AAPL"), 1u);
+    ASSERT_EQ(FIXGatewayActor::symbolFromString("MSFT"), 2u);
+    ASSERT_EQ(FIXGatewayActor::symbolFromString("GOOGL"), 3u);
+    ASSERT_EQ(FIXGatewayActor::symbolFromString("EURO50"), 4u);
+}
+
+void test_symbol_to_string() {
+    ASSERT_TRUE(FIXGatewayActor::symbolToString(1) == "AAPL");
+    ASSERT_TRUE(FIXGatewayActor::symbolToString(2) == "MSFT");
+    ASSERT_TRUE(FIXGatewayActor::symbolToString(3) == "GOOGL");
+    ASSERT_TRUE(FIXGatewayActor::symbolToString(4) == "EURO50");
+    ASSERT_TRUE(FIXGatewayActor::symbolToString(99) == "99");
+}
+
+void test_fix_gateway_creates() {
+    auto oe = std::make_unique<OEGatewayActor>();
+    auto fix = std::make_unique<FIXGatewayActor>(oe->getActorId(), 19010);
+    ASSERT_TRUE(fix->isRunning());
+    ASSERT_EQ(fix->clientCount(), 0);
+    fix->stop();
+    ASSERT_TRUE(!fix->isRunning());
+}
+
+void test_oe_gateway_routes_new_order_event() {
+    auto oe = std::make_unique<OEGatewayActor>();
+    auto md = std::make_unique<MarketDataActor>();
+    auto book = std::make_unique<OrderBookActor>(1, oe->getActorId(), md->getActorId());
+    oe->mapSymbol(1, book->getActorId());
+
+    NewOrderEvent evt(5001, 1, Side::Buy, OrderType::Limit, TimeInForce::Day,
+                       toFixedPrice(150.0), 100, 1);
+    oe->onEvent(evt);
+
+    ASSERT_TRUE(oe->getReports().size() > 0);
+    ASSERT_EQ(oe->getReports().back().status, OrderStatus::New);
+}
+
+void test_exec_report_forwarding() {
+    auto oe = std::make_unique<OEGatewayActor>();
+    auto md = std::make_unique<MarketDataActor>();
+    auto book = std::make_unique<OrderBookActor>(1, oe->getActorId(), md->getActorId());
+    oe->mapSymbol(1, book->getActorId());
+
+    auto fix = std::make_unique<FIXGatewayActor>(oe->getActorId(), 19011);
+    oe->addExecReportSubscriber(fix->getActorId());
+
+    oe->submitNewOrder(1, 1, Side::Buy, OrderType::Limit,
+                        TimeInForce::Day, toFixedPrice(100.0), 50, 1);
+
+    ASSERT_TRUE(oe->getReports().size() > 0);
+
+    fix->stop();
+}
+
+// ── Main ──────────────────────────────────────────────────────────
+
+int main() {
+    std::cout << "FIXGateway Tests\n";
+    std::cout << "═══════════════════════════════════════════\n";
+
+    TEST(symbol_from_string);
+    TEST(symbol_to_string);
+    TEST(fix_gateway_creates);
+    TEST(oe_gateway_routes_new_order_event);
+    TEST(exec_report_forwarding);
+
+    std::cout << "═══════════════════════════════════════════\n";
+    std::cout << testsPassed << " passed, " << testsFailed << " failed\n";
+    return testsFailed > 0 ? 1 : 0;
+}